彻底理解-双重检测单例模式

1. 一般的单例模式如下：

class Singleton{
    private static Singleton singleton;    
    private Singleton(){}
        
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();   // 创建实例
    }
    return singleton;
    }
}   

问题：构造器私有使得外界无法通过构造器实例化Singleton类，要取得实例只能通过getInstance()方法。这是一个延迟加载的版本，即在需要对象的时候才进行实例化操作。该方法在单线程下能够正常运行，但是在多线程环境下会出现由于没有同步措施而导致产生多个单例对象的情况。

原因：在于可能同时有两个线程A和B同时执行到 if 条件判断语句，A判断singleton为空准备执行（//创建实例） 时让出了CPU时间片，B也判断singleton为空，接着执行 （//创建实例），此时创建了一个实例对象；A获取了CPU时间片后接着执行（//创建实例），也创建了实例对象，这就导致多个单例对象的情况

2. 为了解决 1 中出现的问题就是使用synchronized关键字，代码如下：

class Singleton{
    private static Singleton singleton;    
    private Singleton(){}
        
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();    //创建实例
        }
        return singleton;
    }
}

这样解决了多线程并发的问题，但是却带来了效率问题：我们的目的是只创建一个实例，即（//创建实例）处代码只会执行一次，也正是这个地方才需要同步，后面创建了实例之后，singleton非空就会直接返回对象引用，而不用每次都在同步代码块中进行非空验证。

3. 为了解决 2 中出现的问题只对（//创建实例）处进行同步：

class Singleton{
    private static Singleton singleton;    
    private Singleton(){}
    
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){                
                singleton = new Singleton();   //创建实例
            }
        }
        return singleton;
    }
}

这样会带来与第一种一样的问题： 即多个线程同时执行到条件判断语句时，会创建多个实例。

原因： 问题在于当一个线程创建一个实例之后，singleton就不再为空了，但是后续的线程并没有做第二次非空检查

4. 为了解决 3 中出现的问题就是在后续的线程做第二次非空检查，代码如下：

class Singleton{
    private static Singleton singleton;    
    private Singleton(){}
    
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){
                if(singleton == null)
                    singleton = new Singleton();   //创建实例
            }
        }
        return singleton;
    }
}

到这里已经很完美了，看起来没有问题。No！！！因为这种双重检测机制在JDK1.5之前是有问题的，问题还是出在（//创建实例），由所谓的无序写入造成的。

一般来讲，当初始化一个对象的时候，会经历

　　a. 内存分配

　　b. 初始化

　　c. 返回对象引用

这种方式产生的对象是一个完整的对象，可以正常使用。但是JAVA的无序写入可能会造成顺序的颠倒，即

　　a. 内存分配、

　　b. 返回对象引用

　　c. 初始化的顺序，

这种情况下对应到（//创建实例）就是singleton已经不是null，而是指向了堆上的一个对象，但是该对象却还没有完成初始化动作。当后续的线程发现singleton不是null而直接使用的时候，就会出现意料之外的问题。

解决方案：  JDK1.5之后，可以使用volatile关键字修饰变量来解决无序写入产生的问题，因为volatile关键字的一个重要作用是禁止指令重排序，即保证不会出现内存分配、返回对象引用、初始化这样的顺序，从而使得双重检测真正发挥作用

5. 最后的双重检测单例模式为：

public class Singleton{

    private volatile static Singleton instance = null;
    private Singleton() {}

    public static Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {
                    if (instance == null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
     }
}