多线程情况下双重检查锁定问题的分析与优化

双重检查锁定(Double-Checked Locking)的由来

Java程序中，有时候需要推迟一些高开销对象的初始化操作，等到使用的时候才进行对象初始化。双重检查锁定是一种常见的延迟初始化技术。但是在多线程情况下，使用不当很容易出现问题。下面就来分析一下非线程安全的一段代码：

public class DoubleCheckedLocking {
private static Instance instance;

public static Instance getInstance() {
if (instance == null) {					// line A 第一次检查
synchronized (DoubleCheckedLocking.class) {	// line B 加锁
if (instance == null) {			// line C 第二次检查
instance = new Instance();	// line D 创建一个对象。 问题就出在这里！！！
}
}
}
return instance;
}
}

从代码来看，如果第一次检查instance不为null，则不用继续执行加锁和初始化操作，可以降低synchronized带来的性能开销。但是如果在多线程情况下一个线程执行第一次检查的时读取的instance不为null，然而此时instance引用的对象在另外一个线程中还没有初始化完成，这时程序就会出现错误。

2. 问题的根源

可以将上述创建对象的代码进一步分解为下面3行伪代码：

memory = allocate();	//step1. 为对象分配内存空间
createInstance(memory);	//step2. 对象的初始化
instance = memory;	//step3. 设置instance指向分配的内存地址

上面三行代码在执行的时候可能会发生制定重排序。step2和step3重排序之后执行顺序如下：

memory = allocate();	//step1. 为对象分配内存空间
instance = memory;	//step3. 设置instance指向分配的内存地址  此处的对象还没有被初始化，正是问题的所在！！！
createInstance(memory);	//step2. 对象的初始化

在多线程条件下，如果线程A使用第二种指令排序方式来初始化instance对象，当程序执行到step3的时候，若线程B在执行第一次检查，将会获得一个还未初始化的对象，此时线程B就会出现问题。

3. 解决方案

发现问题的根源以后，可以有两个办法来解决。

不允许step2和step3进行指令重排序。
允许step2和step3进行重排序，但是不允许其他线程“看到”此重排序。

3.1. 基于volatile的解决方案

可以对前面DoubleCheckedLocking方法稍作修改（把instance声明为volatile类型，声明为volatile类型后，代码重排序将被禁止），即可实现线程安全的延迟初始化。

public class DoubleCheckedLocking {
private volatile static Instance instance;

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

3.2. 基于类初始化的解决方案

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

public class InstanceFactory {
private static class InstanceHolder {
public static Instance instance = new Instance();
}

public static Instance getInstance(){
return InstanceHolder.instance;
}
}