作者： 一字马胡
转载标志 【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 = 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() {
return InstanceHolder.DEFAULT;
}
}
假设有两个线程同时需要初始化类SingletonClass，那么都需要首先获取一个锁，获取锁成功的线程可以进行初始化工作，没有获取到的线程只能等待，而同一个线程内new的指令重排序是不影响最后结果的。
