java如何安全的延迟初始化 java如何安全的延迟初始化

作者：一字马胡
转载标志【2017-11-03】

更新日志

日期	更新内容	备注
2017-11-03	添加转载标志	持续更新

我们经常需要使用单例模式来为我们工作，而我们一般会使用下面的代码来组织我们的单例模式：

public class SingletonClass { private static SingletonClass _instance = null; private SingletonClass() {}public static SingletonClass getInstance() { if (_instance == null) { synchronized(SingletonClass.class) { if (_instance == null) { _instance = new SingletonClass(); } } } } }

我们称这样的代码为“双重检查锁定”(Double checking locking)，一般情况下，这样的代码不会出现什么问题，毕竟我们的代码中也有类似的代码，但是这样的代码还是会有安全隐患。在这里，我们需要了解一个“new SingletonClass()”背后的过程，新生成一个对对象需要三个过程：
1、申请足够大小的内存空间
2、初始化申请到的内存空间
3、将新对象指向申请的内存空间
如果按照1-2-3的顺序来的话是没有问题的，但是编译器有可能会为了达到最好的效率对指令进行重排序，对于不会影响执行结果的指令，编译器可以进行指令冲排序，上面的2和3之间没有依赖关系，所以可以进行重排序，所以最后new的动作的执行顺序可能为1-3-2，而只要3执行了，那么我们的对象就不是null了啊，虽然还没有初始化。而问题就在这里，假设线程A执行到了“new SingletonClass（）”这一句，然后new动作的指令被重新排序为1-3-2，我们假设线程A执行到3的时候（还没有执行2），线程B来检测“_instance == null”，而线程A已经使得“_instance != null”成立了，所以线程B不再继续执行，但是我们发现线程B获取到的是一个还没有初始化的对象实例，这样做是有安全隐患的，假若线程B获取到_instance之后立刻操作这个对象就会出现问题。
经过我们的分析，我们发现问题在于new的指令被编译器重排序了，我们有两种方法来解决上面的问题：
一、使用volatile来禁止指令重新排序

public class SingletonClass { private static volatile SingletonClass _instance = null; private SingletonClass() {}public static SingletonClass getInstance() { if (_instance == null) { synchronized(SingletonClass.class) { if (_instance == null) { _instance = new SingletonClass(); } } } } }

只需在_instance之前加上volatile，我们就可以解除安全隐患。
二、使用类初始化特性来解决，JVM在进行类初始化时，JVM会去获取一个锁，可以同步多个线程对同一个类的初始化。这也是我们在代码里面见到最多的方式（正确的）。
1、使用final关键字达到我们想要的效果
final关键字保证：只要对象是被正确构造的，也就是在构造函数中没有“逸出”，那么多个线程都能看到构造函数中被初始化的值，也就是可以不使用锁（synchronized等）就可以达到同步的效果，关于“逸出”，指的是对象还没有被构造完成之前就被引用，比如下面的代码：

public class EscapeClass {private static final int value; private static EscapeClass _instance; public EscapeClass(int i){ value = https://www.it610.com/article/i; //initialize the final value _instance = this; // escape here }public static int getValue(){ if (_instance != null) { return _instance.value; } else { return 0; } } public static void init(){ new EscapeClass(); }}

在上面的类EscapeClass中，构造函数里出现了对象引用“逸出”，假设有两个线程，一个线程A执行init方法，而另外一个线程B执行getValue方法，在EscapeClass的构造函数里面的两个操作可能会被重新排序，所以可能首先执行了对象引用:_instance = this的操作，而此时final域还没有被初始化，value的值还不是我们想要的，但是线程B在执行getValue方法的时候发现_instance != null已经成立了，所以他就直接返回了_instance.value，但是实际上EscapeClass构造函数没有执行完成，线程B取到的值不是预期的值，主要的问题还是在指令重排序。
理解了什么是“逸出”，就可以来看下面的代码了，因为SingletonClass的构造函数里面什么都没干，所以不会发生“逸出”的危险。

private class SingletonClass {private static final SingletonClass _instance = new SingletonClass(); private SingletonClass() {}public static SingletonClass getInstance() { return _instance; }}

2、更为一般的写法如下(推荐)：

private class SingletonClass {private static SingletonClass InstanceHolder { public static SingletonClass DEFAULT = new SingletonClass(); }private SingletonClass() {}public static SingletonClass getInstance() { returnInstanceHolder.DEFAULT; }}

【java如何安全的延迟初始化】假设有两个线程同时需要初始化类SingletonClass，那么都需要首先获取一个锁，获取锁成功的线程可以进行初始化工作，没有获取到的线程只能等待，而同一个线程内new的指令重排序是不影响最后结果的。