volatile可以理解为轻量级的synchronized，因为多线程并发访问volatile变量时，不会引起线程上下文的切换。
如果一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
- 在多处理器开发中保证了共享变量的可见性（当一个线程改变了共享变量的值，另一个线程读到的一定是修改之后的值）。
- 禁止指令重排
对可见性理解
对一个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修饰变量后，对变量的读写前后会插入内存屏障，从而禁止这样的重排序。保证程序的正确性。
匆匆写就，诸多深坑，慢慢填。
