单例模式之双重检查的演变

前言

单例模式本身是很简单的，但是考虑到线程安全问题，简单的问题就变复杂了。这里讲解单例模式的双重检查。

单例模式演变

没有多线程的世界

最开始的单例模式应该是如下代码。

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;
    }
}

好生厉害的重排序

这就要牵扯到重新排序问题。为了提高运行速度一般有以下重排序：

1. 编译器优化重排序
2. 指令级并行重排序
3. 内存系统重排序
   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;
    }
}

总结

这里简单总结下单例模式的线程安全问题。之所以出现安全问题有如下原因：

1. 多级缓存与主内存的值不同步。
2. 重排序问题。
3. 对临界区的访问问题。
   因此只要解决上述三个问题，基本上就解决单例模式的线程安全问题。