Java - 单例陷阱——双重检查锁中的指令重排问题

单例回顾

首先我们回顾一下最简单的单例模式是怎样的？

/***单例模式一：懒汉式（线程安全）*/publicclassSingleton1 {
privatestaticSingleton1singleton1;
privateSingleton1() {
    }
publicstaticSingleton1getInstance() {
if (singleton1==null) {
singleton1=newSingleton1();
        }
returnsingleton1;
    }
}

这是一个懒汉式的单例实现，众所周知，因为没有相应的锁机制，这个程序是线程不安全的，实现安全的最快捷的方式是添加 synchronized

/*** 单例模式二：懒汉式（线程安全）*/publicclassSingleton2 {
privatestaticSingleton2singleton2;
privateSingleton2() {
    }
publicstaticsynchronizedSingleton2getInstance() {
if (singleton2==null) {
singleton2=newSingleton2();
        }
returnsingleton2;
    }
}

使用synchronized之后，可以保证线程安全，但是synchronized将全部代码块锁住，这样会导致较大的性能开销，因此，人们想出了一个“聪明”的技巧：双重检查锁DCL(double checked locking)的机制实现单例。

双重检查锁

一个双重检查锁实现的单例如下所示

/*** 单例模式三：DCL(double checked locking)双重校验锁*/publicclassSingleton3 {
privatestaticSingleton3singleton3;
privateSingleton3() {
    }
publicstaticSingleton3getInstance() {
if (singleton3==null) {
synchronized (Singleton3.class) {
if (singleton3==null) {
singleton3=newSingleton3();
                }
            }
        }
returnsingleton3;
    }
}

如上面代码所示，如果第一次检查instance不为null，那么就不需要执行下面的加锁和初始化操作。因此可以大幅降低synchronized带来的性能开销。上面代码表面上看起来，似乎两全其美：

1. 在多个线程试图在同一时间创建对象时，会通过加锁来保证只有一个线程能创建对象。
2. 在对象创建好之后，执行getInstance()将不需要获取锁，直接返回已创建好的对象。

程序看起来很完美，但是这是一个不完备的优化，在线程执行到第9行代码读取到instance不为null时（第一个if），instance引用的对象有可能还没有完成初始化。

问题的根源

问题出现在创建对象的语句singleton3 = new Singleton3(); 上，在java中创建一个对象并非是一个原子操作，可以被分解成三行伪代码：

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

上面三行伪代码中的2和3之间，可能会被重排序（在一些JIT编译器中）,即编译器或处理器为提高性能改变代码执行顺序，这一部分的内容稍后会详细解释，重排序之后的伪代码是这样的：

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

在单线程程序下，重排序不会对最终结果产生影响，但是并发的情况下，可能会导致某些线程访问到未初始化的变量。

模拟一个2个线程创建单例的场景，如下表

按照这样的顺序执行，线程B将会获得一个未初始化的对象，并且自始至终，线程B无需获取锁！

指令重排序

前面我们已经分析到，导致问题的原因在于“指令重排序”，那么什么是“指令重排序”，它为什么在并发时会影响到程序处理结果？ 首先我们看一下“顺序一致性内存模型”概念。

顺序一致性理论内存模型

顺序一致性内存模型是一个被计算机科学家理想化了的理论参考模型，它为程序员提供了极强的内存可见性保证。顺序一致性内存模型有两大特性：

1. 一个线程中的所有操作必须按照程序的顺序来执行。
2. （不管程序是否同步）所有线程都只能看到一个单一的操作执行顺序。在顺序一致性内存模型中，每个操作都必须原子执行且立刻对所有线程可见。

实际JMM模型

但是，顺序一致性模型只是一个理想化了的模型，在实际的JMM实现中，为了尽量提高程序运行效率，和理想的顺序一致性内存模型有以下差异：

在顺序一致性模型中，所有操作完全按程序的顺序串行执行。在JMM中不保证单线程操作会按程序顺序执行（即指令重排序）。 顺序一致性模型保证所有线程只能看到一致的操作执行顺序，而JMM不保证所有线程能看到一致的操作执行顺序。 顺序一致性模型保证对所有的内存写操作都具有原子性，而JMM不保证对64位的long型和double型变量的读/写操作具有原子性（分为2个32位写操作进行，本文无关不细阐述）

指令重排序

指令重排序是指编译器或处理器为了优化性能而采取的一种手段，在不存在数据依赖性情况下（如写后读，读后写，写后写），调整代码执行顺序。 举个例子

//Adoublepi=3.14;
//Bdoubler=1.0;
//Cdoublearea=pi*r*r;

这段代码C依赖于A,B，但A，B没有依赖关系，所以代码可能有2种执行顺序：

1. A->B->C
2. B->A->C 但无论哪种最终结果都一致，这种满足单线程内无论如何重排序不改变最终结果的语义，被称作as-if-serial语义，遵守as-if-serial语义的编译器，runtime 和处理器共同为编写单线程程序的程序员创建了一个幻觉： 单线程程序是按程序的顺序来执行的。

双重检查锁问题解决方案

回来看下我们出问题的双重检查锁程序，它是满足as-if-serial语义的吗？是的，单线程下它没有任何问题，但是在多线程下，会因为重排序出现问题。

解决方案就是大名鼎鼎的volatile关键字，对于volatile我们最深的印象是它保证了”可见性“，它的”可见性“是通过它的内存语义实现的:

• 写volatile修饰的变量时，JMM会把本地内存中值刷新到主内存
• 读volatile修饰的变量时，JMM会设置本地内存无效

重点：为了实现可见性内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来防止重排序！

对之前代码加入volatile关键字，即可实现线程安全的单例模式。

/*** 单例模式三：DCL(double checked locking)双重校验锁*/publicclassSingleton3 {
privatestaticvolatileSingleton3singleton3;
privateSingleton3() {
    }
publicstaticSingleton3getInstance() {
if (singleton3==null) {
synchronized (Singleton3.class) {
if (singleton3==null) {
singleton3=newSingleton3();
                }
            }
        }
returnsingleton3;
    }
}