双重检查锁为何要使用volatile字段?

双重锁的由来

单例模式中，有一个DCL(双重锁)的实现方式。在Java程序中，有时候可能须要推迟一些高开销的对象初始化操做，而且只有在使用这些对象时才开始初始化。

下面是非线程安全的延迟初始化对象的实例代码。

/**
 * @author xiaoshu
 */
public class Instance {
}

/**
 * 非线程安全的延迟初始化对象
 *
 * @author xiaoshu
 */
public class UnsafeLazyInitialization {
    private static Instance instance;

    public static Instance getInstance() {
        if (null == instance) {
            instance = new Instance();
        }
        return instance;
    }
}

在UnsafeLazyInitialization类中，假设A线程执行代码1的同时，B线程执行代码2。此时，线程A可能会看到instance引用对象尚未完成初始化。

对于UnsafeLazyInitialization类，咱们能够对getInstance()方法作同步处理来实现线程安全的延迟初始化。示例代码以下。

/**
 * 安全的延迟初始化
 *
 * @author xiaoshu
 */
public class SafeLazyInitialization {
    private static Instance instance;

    public synchronized static Instance getInstance() {
        if (null == instance) {
            instance = new Instance();
        }
        return instance;
    }
}

因为对getInstance()方法作了同步处理，synchronized将致使性能开销。若是getInstance()方法被多个线程频繁的调用，将会致使程序执行性能的降低。反之，若是getInstance()方法不会被多个线程频繁的调用，那么这个延迟初始化方案将能提供使人满意的性能。

后来，提出了一个“聪明”的技巧：双重检查锁定（Double-Checked Locking)。想经过双重检查锁定来下降同步的开销。下面是使用双重检查锁定来实现延迟初始化的实例代码。

/**
 * 双重检查锁定
 *
 * @author xiaoshu
 */
public class DoubleCheckedLocking {
    private static Instance instance;

    public static Instance getInstance() {
        if (null == instance) {                             //1.第一次检查
            synchronized (DoubleCheckedLocking.class) {     //2.加锁
                if (null == instance) {                     //3：第二次检查
                    instance = new Instance();              //4.问题的根源出在这里
                }
            }
        }
        return instance;
    }
}

双重检查锁定看起来彷佛很完美，但这是一个错误的优化！在线程执行到第1处，代码读取到instance不为null时，instance引用的对象有可能尚未完成初始化。

问题的根源

前面的双重检查锁定实例代码的第4处（instance = new Instance();)建立了一个对象。这一行代码能够分解为以下的3行伪代码。

memory = allocate();    //1.分配对象的内存空间
ctorInstance(memory); //2.初始化对象
instance = memory;        //3.设置instance指向刚分配的内存地址

上面3行伪代码中的2和3之间，可能会被重排序（在一些JIT编译器上，这种重排序是真实发生的），2和3之间重排序以后的执行时序以下：

memory = allocate();    //1.分配对象的内存空间
instance = memory;        //3.设置instance指向刚分配的内存地址
                                            //注意，此时对象尚未被初始化！
ctorInstance(memory); //2.初始化对象

多线程执行时序表

时间	线程A	线程B
T1	A1:分配对象的内存空间
T2	A3:设置instance指向内存空间
T3		B1：判断instance是否为空
T4		B2：因为instance不为null，线程B将访问instance引用的对象
T5	A2:初始化对象
T6	A4:访问instance引用的对象

在知晓了问题发生的根源以后，咱们能够想出两个方法来实现线程安全的延迟初始化。

1）不容许2和3重排序

2）容许2和3重排序，但不容许其余线程“看到”这个重排序。

后文介绍的两个解决方案，分别对应于上面这两点。

解决方案一：基于volatile的解决方案

/**
 * 安全的双重检查锁定
 *
 * @author xiaoshu
 */
public class SafeDoubleCheckedLocking {
    private volatile static Instance instance;

    public static Instance getInstance() {
        if (null == instance) {
            synchronized (SafeDoubleCheckedLocking.class) {
                if (null == instance) {
                    instance = new Instance();//instance为volatile，如今没有问题了。
                }
            }
        }
        return instance;
    }
}

注意：这个解决方案须要JDK5或更高版本（由于从JDK5开始使用新的JSR-133内存模型规范，这个规范加强了volatile的语义）。

当声明对象的引用为volatile后，3行伪代码中的2和3之间的重排序，在多线程环境中将会被禁止。

解决方案二：基于类初始化的解决方案

JVM在类的初始化阶段（即在Class被加载后，且被线程使用以前），会执行类的初始化。在执行类的初始化期间，JVM会去获取一个锁.这个锁能够同步多个线程对同一个类的初始化。

基于这个特性，能够实现另外一种线程安全的延迟初始化方案（这个方案被称之为Initialization On Demand Holder idiom)。

/**
 * 基于类初始化的解决方案
 *
 * @author xiaoshu
 */
public class InstanceFactory {
    private static class InstanceHolder {
        private static Instance instance = new Instance();
    }

    public static Instance getInstance() {
        return InstanceHolder.instance; //这里将致使InstanceHolder类被初始化
    }
}

字段延迟初始化下降了初始化类或建立实例的开销，但增长了访问被延迟初始化的字段的开销。在大多数时候，正常的初始化要优于延迟初始化。若是确实须要对实例字段使用线程安全的延迟初始化，请使用上面介绍的基于volatile的延迟初始化的方案；若是确实须要对静态字段使用线程安全的延迟初始化，请使用上面介绍的基于类初始化的方案。

参考：

1. 《Java并发编程的艺术》