单例模式

本文参考：《修炼Java开发技术：在架构中体验设计模式和算法之美   于广编著》。

 

单例模式也被称为单件模式（或单体模式），主要作用是控制某个类型的实例数量是一个，而且只有一个。对于单例模式而言，不管采用何种实现方式，它都是只关心实例的创建问题，保证运行期间只会被创建一类实例，并不关心具体的业务功能。

 

实现单例的方式：

  1、外部方式：客户程序使用某些全局对象时，做一些”Try-Use“的工作。如果没有，就自己创建一个，把它放在全局的位置，如果本来就有，直接拿过来一个现成的使用。

  2、内部方式：类型自己控制生成实例的数量，无论客户程序是否尝试过了，类型自己控制只提供一个实例，客户程序使用的都是这个现成的唯一实例。

 

单例模式的特点：

1、该类只有一个实例。

2、该类自行创建该实例。

3、向整个系统公开这个实例接口。

 

 单例模式的种类：

1、懒汉式单例

  懒汉式单例是指在类加载的时候不创建单例实例，只有在第一次请求实例的时候创建，并且只在第一次创建后，以后不再创建该类的实例。

package org.dyb.design.singleton;

public class Singleton {
    /**
     * 储存创建好的实例
     */
    private static Singleton instance = null;
    private Singleton(){}//私有的构造器
    /**
     *为客户端提供实例
     *@return Singleton的实例
     */
    public static synchronized Singleton getInstance(){
        if(null == instance)
            return new Singleton();
        return instance;
    }
}

 2、饿汉式单例

  饿汉式单例是指在类被加载的时候，唯一实例已经被创建。

package org.dyb.design.singleton;

public class Singleton {
    private static Singleton instance = new Singleton();//在自身被加载时实例化
    private Singleton(){}//使用private禁止外部进行实例化
    public static Singleton getInstance(){
        return instance;
    }
}

 3、登记式单例

  登记式单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。

package org.dyb.design.singleton;

import java.util.HashMap;
import java.util.Map;

public class RegSingleton {
    /**
     * 登记薄,用来存放所有登记的实例
     */
    private static Map<String,RegSingleton> m_registry = new HashMap<>();
    //在类加载的时候添加一个实例进去
    static {
        RegSingleton x = new RegSingleton();
        m_registry.put(x.getClass().getName(), x);
    }
    protected RegSingleton(){}//同一包下或者子类可以自己实例，这样就可以管理实例组
    /**
     * 对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回
     * @return RegSingleton实例
     */
    public static RegSingleton getInstance(String name){
        if(null == name){
            name = "RegSingleton";
        }
        if(m_registry.get(name) == null){
            try {
                m_registry.put(name, (RegSingleton)Class.forName(name).newInstance());
            } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }    
        return m_registry.get(name);
    }
    
}

 

双重检查加锁：

  因为懒汉式的实现是线程安全的，所以会降低整个访问速度，而且每次访问都要判断一次。更好的实现方式可以使用”双重检查加锁“的方式，这样既可以实现线程安全也不会使性能受到很大的影响。

  所谓的双重检查加锁机制，是指并不是每次进入getInstance方法都需要同步，而是先不同步。当进入方法后，先检查实例是否存在，如果不存在才进行下面的同步块，这是第一重检查，进入同步块后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查，这样以来整个过程只需要一次同步，从而减少了多次在同步情况下进行判断所浪费的时间。

  在使用”双重检查加锁“机制实现时，需要使用关键字”volatile“，含义是被volatile修饰的变量的值不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确地处理该变量。该机制只能用在Java5以上的版本，原因是在Java1.4以前jvm对于volatile关键字的实现存在问题。

package org.dyb.design.singleton;

public class Singleton {
    /**
     * 储存创建好的实例
     */
    private volatile static Singleton instance = null;
    private Singleton(){}//私有的构造器
    public static Singleton getInstance(){
        if(null == instance){
            //同步块，线程安全创建实例
            synchronized(Singleton.class){
                if(null == instance){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

 这种实现方式不但可以实现线程安全的创建实例，而且又不会对性能造成太大的影响。它只是第一次创建市里的时候同步，以后就不需要同步的了，从而加快了运行速度。因为volatile关键字可能会屏蔽掉虚拟机中一些必需的代码优化，所以运行效率并不是很高。所以在此建议读者，如果没有特别的需要，不要使用volatile关键字。也就是说，虽然可以使用”双重检查加锁“机制来实现线程安全的单例，但是不建议大量采用，可以根据情况来选用。

 

一种更好的方式：

  上面常见的两种方式（懒汉式和饿汉式）都存在小小的缺陷，有没有一种方式既能够实现延迟加载又能够实现线程安全呢？

  采用类级内部类能够让类装载的时候不去初始化对象，在这个类级内部类里面去创建对象实例，这样只要不使用到这个类级内部类，那就不会创建对象实例，从而能同时实现延迟加载和线程安全。

package org.dyb.design.singleton;

public class Singleton {
    /**
     *类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，
     *而且只有被调用到才会装载，从而实现了延迟加载 
     */
    private static class SingletonHolder{
        private static Singleton instance = new Singleton();
    }
    private Singleton(){}
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

 这样，当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会被虚拟机在装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问开销。

 

单例和枚举：

单元素的枚举类型已经称为实现Singleton的最佳方法。Java的枚举类型实质上是功能齐全的类，因此可以有自己的属性和方法。Java枚举类型的基本思想是通过公有静态final域为每个枚举常量导出实例的类。从某个角度来讲，枚举是单例的泛型花，本质上是单元素的枚举。

package org.dyb.design.singleton;

public enum SingletonEnum {
    uniqueInstance;
    public void singletonOperation(){
        System.out.println("hello world");
    }
}

 测试：

package org.dyb.design.singleton;

import org.junit.Test;

public class TestSingleton {

    @Test
    public void test(){
        SingletonEnum.uniqueInstance.singletonOperation();
    }
}

 使用枚举来实现单例控制，会更加简洁，而且无偿的提供了序列化的机制，并由jvm从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

 

单例模式的本质：

单例模式的本质是控制实例的数目，单例模式是为了控制在运行期间，让某些类的实例数目只能有一个。其实我们也可以控制实例的数据是2个、3个或者多个，目的都是一样的，节省资源，有时候单个不能满足需求，怎么办？利用map将实例的对象缓存下来，客户端调用的时候通过算法返回实例，如下例子（调度算法省略）：

package org.dyb.design.singleton;

import java.util.HashMap;
import java.util.Map;

public class RegSingleton {
    public final static String DEFAULT_PREKEY = "Cache";
    /**
     * 用来记录当前正在使用哪一个实例
     */
    private static int num = 1;
    /**
     * 最大的实例缓存数量
     */
    private final static int NUM_MAX = 3;
    /**
     * 登记薄,用来存放所有登记的实例
     */
    private static Map<String, RegSingleton> m_registry = new HashMap<>();
    protected RegSingleton() {
    }
    /**
     * 对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回
     * 
     * @return RegSingleton实例
     */
    public static RegSingleton getInstance() {
        String key = DEFAULT_PREKEY + num;
        RegSingleton regSingleton = m_registry.get(key);//num++; 循环使用，这个可以自己写算法来替换
        if (regSingleton == null) {
            regSingleton = new RegSingleton();
            m_registry.put(key, regSingleton);//缓存实例
        }
        num++;
        if(num>NUM_MAX){
            num = 1;
        }
        return regSingleton;
    }
}

测试：

package org.dyb.design.singleton;

import org.junit.Test;

public class TestRegSingleton {

    @Test
    public void test(){
        RegSingleton t1 = RegSingleton.getInstance();
        RegSingleton t2 = RegSingleton.getInstance();
        RegSingleton t3 = RegSingleton.getInstance();
        RegSingleton t4 = RegSingleton.getInstance();
        RegSingleton t5 = RegSingleton.getInstance();
        RegSingleton t6 = RegSingleton.getInstance();
        RegSingleton t7 = RegSingleton.getInstance();
        RegSingleton t8 = RegSingleton.getInstance();
        RegSingleton t9 = RegSingleton.getInstance();
        
        System.out.println("t1 = " +t1);
        System.out.println("t2 = " +t2);
        System.out.println("t3 = " +t3);
        System.out.println("t4 = " +t4);
        System.out.println("t5 = " +t5);
        System.out.println("t6 = " +t6);
        System.out.println("t7 = " +t7);
        System.out.println("t8 = " +t8);
        System.out.println("t9 = " +t9);
        
        
    }
}

 结果：

t1 = org.dyb.design.singleton.RegSingleton@1d0e2c9
t2 = org.dyb.design.singleton.RegSingleton@d8fd1a
t3 = org.dyb.design.singleton.RegSingleton@1d0e17a
t4 = org.dyb.design.singleton.RegSingleton@1d0e2c9
t5 = org.dyb.design.singleton.RegSingleton@d8fd1a
t6 = org.dyb.design.singleton.RegSingleton@1d0e17a
t7 = org.dyb.design.singleton.RegSingleton@1d0e2c9
t8 = org.dyb.design.singleton.RegSingleton@d8fd1a
t9 = org.dyb.design.singleton.RegSingleton@1d0e17a

结果：147,258,369是一样的。

 

使用单例模式的场景：

1、要求生成唯一序列号的场景。

2、在整个项目中需要有访问一个共享访问点或者共享数据，例如一个web页面的计数器。

3、创建一个对象需要消耗的资源过多，如要访问I/O、访问数据库等资源。

4、需要定义大量的静态常量和静态方法（如工具类）的环境。也可以直接声明static形式。