线程安全的单例设计模式（java）

单例设计模式中，懒加载方式写法如下：

public class UnsafeLazyInitialization {
    private static Instance instance;

    public static Instance getInstance() {
        if (instance == null) {
            instance = new Instance();
        }
        return instance;
    }
}

这种方式存在并发问题，当线程A和线程B都同时判断instance是否为null时，判断结果都为空，所以都会进行初始化，不符合单例要求。且instance = new Instance()这个步骤里包含了多个步骤，包括分配内存，初始化对象，将内存地址赋值为引用变量等，而instance是普通变量，所以可能以上步骤存在重排序。重排序后，会发生对象实际上还没有被初始化好，但是另外一个线程已经判断instance不为空，开始访问对象中的成员变量，导致错误发生。

下面这种写法也是错误的：

public class SafeLazyInitialization {
    private static Instance instance;

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

这种写法相对于第一种，虽然都new一个新对象的问题解决了，但是第二个由于重排序导致的问题还是不能够解决。instance = new Instance()能够被分解为：

memory = allocate();  //1、分配内存空间
initInstance(memory); //2、初始化对象
instance = memory;    //3、将内存地址赋值给instance引用变量

由于instance属于普通类型的对象，而且在单线程下执行以上程序，与2、3重排序后的执行结果一致，所以可能存在重排序的情况。当执行顺序是132时，另一个线程在3执行结束后就认为instance对象已经初始化完成，所以就会开始访问成员变量，此时就存在问题。所以一种简单的解决方法就是借助volatile的特性：

public class SafeDubboCheckLocking {
    private static volatile Instance instance;

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

这一次，有两个变化。1是instance变量成为了volatile变量，所以JMM会禁止volatile写于之前的所有操作重排序（参考volatile语义深入理解），这样就解决了上面说的问题。还有一个变化是采用了双重判断的方式，这种方式的效率更高，不用每次先加锁。

其实还有一种方式，写法更为简单，也不存在线程安全的问题。利用了类初始化（加载、链接、初始化中的初始化）的时机，以及JVM对于初始化并发的控制。

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

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

类只会被初始化一次，所以这样也是单例的。由于初始化也会存在多个线程一起初始化的情况，所以JVM做了线程安全的保证，也是通过锁的方式，具体可以参看《并发编程的艺术》这本书中第三章关于单例解决方案的部分。