Java 由volatile 关键字到Double-Check单例模式

首先看下关键字volatile 的作用：

1.volatile 保证了可见性，保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2.volatile 不能保证原子性；什么是原子性呢？

原子性： 即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行 。

例如：i++ 这个操作就不具备原子性：因为它包含3步：读取i的值，进行加1操作，写入新的值。
3.volatile 能够禁止指令重排序 ，即 当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

//x、y为非volatile变量
//flag为volatile变量
 
x = 1;        //语句1
y = 1;        //语句2
flag = true;  //语句3
x = 2;         //语句4
y = -1;       //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。

并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

public class JoinMeetHelper {

    private static JoinMeetHelper mInstance;

    private JoinMeetHelper(){
    }

    public static JoinMeetHelper getInstance(){
        if (mInstance == null){  //语句1
            synchronized (JoinMeetHelper.class){//语句2
                if (mInstance == null){//语句3
                    mInstance = new JoinMeetHelper();//语句4
                }
            }
        }
        return mInstance;
    }   
 
}

这个Double-Check意思很明显，这里也解释下，上面的getInstance方法里，我注释了4个语句。
注：
语句1这个非空判断是为了提高效率，如果不加语句1，那么每次调用getInstance都会直接去获取同步锁，影响效率；
语句3的作用我们举例来说，假设有2个线程A和B，都执行完了语句1，此时线程A获取了锁，执行完同步代码块后，线程B获得了锁执行语句3，发现mInstance已经实例化了，所以线程B就直接返回这个实例了。

但是这个单例模式可能会出现问题，因为语句4不是原子性操作，他包含以下3个步骤：

1. 给 singleton 分配内存

2. 调用 Singleton 的构造函数来初始化成员变量，形成实例

3. 将singleton对象指向分配的内存空间（执行完这步 singleton才是非 null了）

由于JVM存在指令重排序，所以步骤2和3的顺序是不可知的；

也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
　　
再稍微解释一下，就是说，由于有一个『mInstance已经不为null但是仍没有完成初始化』的中间状态，而这个时候，如果有其他线程刚好运行到第一层if (mInstance==null)这里，这里读取到的mInstance已经不为null了，所以就直接把这个中间状态的instance拿去用了，就会产生问题。这里的关键在于线程A对mInstance的写操作没有完成，线程B就执行了读操作。

对于这个问题的解决方法是在声明变量mInstance的前面加上 volatile关键字。它的原理是把instance声明为volatile之后，对它的写操作就会有一个内存屏障，这样，在它的赋值完成之前，就不用会调用读操作。即 volatile禁止指令重排序。