volatile浅析

volatile可以理解为轻量级的synchronized，因为多线程并发访问volatile变量时，不会引起线程上下文的切换。
如果一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1. 在多处理器开发中保证了共享变量的可见性（当一个线程改变了共享变量的值，另一个线程读到的一定是修改之后的值）。
2. 禁止指令重排

对可见性理解

对一个volatile变量的读/写，效果上等价于对这个变量做了同步，示例代码如下：

public class VolatileExample {

    volatile long v1 = 0l;

    public void setV1(long l){
        v1 = l;
    }

    public long getV1(){
        return v1;
    }

    public void getAndIncrement(){
        v1 ++;
    }
}

等价于

public class VolatileExample {

    long v1 = 0l;

    //使用synchronized进行同步
    public synchronized void setV1(long l){
        v1 = l;
    }

    //使用synchronized进行同步
    public synchronized long getV1(){
        return v1;
    }
    
    public void getAndIncrement(){
        long temp = getV1();
        temp += 1l;
        setV1(temp);
    }
}

对指令重排的理解

在执行程序时，为了提高性能，编译器和处理器可能会对指定进行重排序。下面通过一段经典的单例双重检查(DoubleCheckLocking )来了解一下编译器级别的重排序。

public class Singleton {

    private volatile static Singleton instance = null;

    private Singleton() {}

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

从代码上，可以看到instance被定义为volatile变量。new Singleton()已经被放在同步块中了，为什么还需要用volatile修饰呢？
正常来讲，new Singleton()可以分解为以下三个步骤为：

 memory =allocate();        //1：分配对象的内存空间 
 ctorInstance(memory);    //2：初始化对象 
 instance =memory;          //3：设置instance指向刚分配的内存地址

但是这三个步骤并不一定会被顺序执行，可能会被重排为：

 memory = allocate();        //1：分配对象的内存空间 
 instance = memory;         //2：设置instance指向刚分配的内存地址
 ctorInstance(memory);     //3：初始化对象 

一旦发生这样的重排序，在对象尚未完成初始化时，对象的引用就可能会被其他线程读取到。而使用volatile修饰变量后，对变量的读写前后会插入内存屏障，从而禁止这样的重排序。保证程序的正确性。

匆匆写就，诸多深坑，慢慢填。