双重锁的由来
单例模式中，有一个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的延迟初始化的方案；如果确实需要对静态字段使用线程安全的延迟初始化，请使用上面介绍的基于类初始化的方案。
参考：
- 《Java并发编程的艺术》
