前言
单例模式本身是很简单的，但是考虑到线程安全问题，简单的问题就变复杂了。这里讲解单例模式的双重检查。
单例模式演变
没有多线程的世界
最开始的单例模式应该是如下代码。
public class Singleton {
private static Singleton singleton = null;
public static Singleton getSingleton() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
然后有人说你这个是线程不安全的。为什么是线程不安全？举个例子。
A线程由于第一次进来由于 singleton实例为空，所以执行new Singleton()，然后将singleton返回。由于多级缓存的存在，这个实例有可能只存在A线程的工作内存中，并没用立即往主内存中写。这个时候B线程进来一样判断singleton == null，B线程取singleton有两个地方一个是自己的工作内存，另一个是主内存，但是都没有，因此B线程也要创建一遍singleton。
工作内存与主内存数据同步
这个时候就有人说了，我们在singleton加上volatile关键字，这样只要有线程创建singleton，都会往主内存中写，并且所有的线程都是可见的。因此就有如下代码。
public class Singleton {
// 加入volatile，所有线程都从主内存中取值。
private static volatile Singleton singleton = null;
public static Singleton getSingleton() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
但是还是有线程安全问题，比如第一个线程在创建singleton实例（还没有创建完成），第二个线程判断singleton==null 为true，所以依然会创建两次singleton。这个时候就会想，直接来个简单粗暴的方法，直接在方法上加synchronized。
简单粗暴的方法
public class Singleton {
private static Singleton singleton = null;
public static synchronized Singleton getSingleton() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
这下总算是满足既要单例，又要线程安全。当一直出现问题的时候，人们就想着赶快给我简单粗暴的解决方案吧，只要解决问题就行，不管什么方法都ok。当问题得到解决的时候，程序也运行了一段时间，人们又想着锁住整个方法，这也太菜了，我得想着优化方法。锁住部分代码。
在优化的路上渐行渐远
但是这也会出现线程安全问题，如下代码线程A进入创建singleton，趁着线程A还没有完全创建singleton，线程B登场，由于A还在临界区内，B线程只能等待，接着A线程执行完，线程B进入临界区创建singleton，两次创建singleton，所以线程不安全。
public class Singleton {
private static Singleton singleton = null;
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
singleton = new Singleton();
}
}
return singleton;
}
}
public class Singleton {
private static volatile Singleton singleton = null;
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
singleton = new Singleton();
}
}
return singleton;
}
}
上面两个线程不安全是因为第二个线程会进入临界区，并且创建singleton，所以就有人提出在临近区也对singleton进行判空。如下代码，第二个线程进入临界区的时候判断singleton == null ，由于第一个线程已经创建了singleton并且释放锁了，JMM会将线程A的singleton对象刷新到主内存中，因此第二个线程从主内存中获取到singletone，所以不会再次创建singleton实例。乍一想好像没有什么问题，但是以下代码还是会存在线程安全问题。这是为何？
public class Singleton {
private static Singleton singleton = null;
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
好生厉害的重排序
这就要牵扯到重新排序问题。为了提高运行速度一般有以下重排序：
- 编译器优化重排序
- 指令级并行重排序
- 内存系统重排序
singleton = new Singleton()看上去是一行代码，其实编译后对应的多条字节码指令，一条字节码指令可能转换多条机器指令。可以简单的把创建对象的过程看做以下步骤
1. 分配对象内存空间
2. 初始化构造函数
3. 赋值
按照顺序执行并没有什么毛病，但是如果出现重排序将123变成132那么对象没有初始化完就被第二个线程看到，所以上述的代码存在的问题是第一个线程执行了13过程，第二个线程执行到singleton == null 这个时候由于singleton 引用已经指向内存中的某块区域，所以singleton== null判断就为false，接下来第二个线程使用没有初始化完成的对象。这个线程安全问题是重排序导致的，因此只要解决重排序问题，就解决了该代码的线程安全问题，这个时候就该引入volatile，被volatile的字段写入的时候，JMM会在写入前插入一个StoreStore屏障，意思就是写volatile字段之前，前面的写操作都已完成，在这里这个屏障就是插入在23之间，因此singleton被volatile修饰后，指令执行3操作前12操作都已完成。所以其他线程只要看到了singleton对象，那么该对象就一定初始化完成，因此这就解决了线程安全问题。
public class Singleton {
private static volatile Singleton singleton = null;
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
总结
这里简单总结下单例模式的线程安全问题。之所以出现安全问题有如下原因：
- 多级缓存与主内存的值不同步。
- 重排序问题。
- 对临界区的访问问题。
因此只要解决上述三个问题，基本上就解决单例模式的线程安全问题。
