双重检查锁为什么要使用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 并发编程的艺术》