volatile关键字

当一个共享变量被volatile修饰时，它会保证修改的值立即被更新到主存“， 这里的”保证“ 是如何做到的?和 JIT的具体编译后的CPU指令相关吧?

volatile特性

内存可见性：通俗来说就是，线程A对一个volatile变量的修改，对于其它线程来说是可见的，即线程每次获取volatile变量的值都是最新的。

volatile的使用场景

通过关键字sychronize可以防止多个线程进入同一段代码，在某些特定场景中，volatile相当于一个轻量级的sychronize，因为不会引起线程的上下文切换，但是使用volatile必须满足两个条件：

1、对变量的写操作不依赖当前值，如多线程下执行a++，是无法通过volatile保证结果准确性的;

2、该变量没有包含在具有其它变量的不变式中，这句话有点拗口，看代码比较直观。

public class NumberRange {
　　private volatile int lower = 0;

　　private volatile int upper = 10;

　　public int getLower() { return lower; }

　　public int getUpper() { return upper; }

　　public void setLower(int value) {

　    　if (value > upper)

　    　throw new IllegalArgumentException(...);

　    　lower = value;

　　}

　　public void setUpper(int value) {

　    　if (value < lower)

　    　throw new IllegalArgumentException(...);

　    　upper = value;

　　}

}

上述代码中，上下界初始化分别为0和10，假设线程A和B在某一时刻同时执行了setLower(8)和setUpper(5)，且都通过了不变式的检查，设置了一个无效范围(8, 5)，所以在这种场景下，需要通过sychronize保证方法setLower和setUpper在每一时刻只有一个线程能够执行。

下面是我们在项目中经常会用到volatile关键字的两个场景：

1、状态标记量

在高并发的场景中，通过一个boolean类型的变量isopen，控制代码是否走促销逻辑，该如何实现?

public class ServerHandler {

　　private volatile isopen;

　　public void run() {
　    　if (isopen) {
　          　//促销逻辑
　    　} else {
　         　//正常逻辑
　　    }
　　}

　　public void setIsopen(boolean isopen) {
　    　this.isopen = isopen
　　}
}

场景细节无需过分纠结，这里只是举个例子说明volatile的使用方法，用户的请求线程执行run方法，如果需要开启促销活动，可以通过后台设置，具体实现可以发送一个请求，调用setIsopen方法并设置isopen为true，由于isopen是volatile修饰的，所以一经修改，其他线程都可以拿到isopen的最新值，用户请求就可以执行促销逻辑了。

2、double check

单例模式的一种实现方式，但很多人会忽略volatile关键字，因为没有该关键字，程序也可以很好的运行，只不过代码的稳定性总不是100%，说不定在未来的某个时刻，隐藏的bug就出来了。

class Singleton {

　　private volatile static Singleton instance;

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

不过在众多单例模式的实现中，我比较推荐懒加载的优雅写法Initialization on Demand Holder(IODH)。

public class Singleton {

　　static class SingletonHolder {

　　static Singleton instance = new Singleton();

　　}

　　public static Singleton getInstance(){

　　return SingletonHolder.instance;

　　}

　　}

如何保证内存可见性?

在java虚拟机的内存模型中，有主内存和工作内存的概念，每个线程对应一个工作内存，并共享主内存的数据，下面看看操作普通变量和volatile变量有什么不同：

1、对于普通变量：读操作会优先读取工作内存的数据，如果工作内存中不存在，则从主内存中拷贝一份数据到工作内存中;写操作只会修改工作内存的副本数据，这种情况下，其它线程就无法读取变量的最新值。

2、对于volatile变量，读操作时JMM会把工作内存中对应的值设为无效，要求线程从主内存中读取数据;写操作时JMM会把工作内存中对应的数据刷新到主内存中，这种情况下，其它线程就可以读取变量的最新值。

volatile变量的内存可见性是基于内存屏障(Memory Barrier)实现的，什么是内存屏障?内存屏障，又称内存栅栏，是一个CPU指令。在程序运行时，为了提高执行性能，编译器和处理器会对指令进行重排序，JMM为了保证在不同的编译器和CPU上有相同的结果，通过插入特定类型的内存屏障来禁止特定类型的编译器重排序和处理器重排序，插入一条内存屏障会告诉编译器和CPU：不管什么指令都不能和这条Memory Barrier指令重排序。

代码示例如下：

class Singleton {

　　private volatile static Singleton instance;

　　private int a;

　　private int b;

　　private int b;

　　public static Singleton getInstance() {

　　if (instance == null) {

　　syschronized(Singleton.class) {

　　if (instance == null) {

　　a = 1; // 1

　　b = 2; // 2

　　instance = new Singleton(); // 3

　　c = a + b; // 4

　　}

　　}

　　}

　　return instance;

　　}

　　}

1、如果变量instance没有volatile修饰，语句1、2、3可以随意的进行重排序执行，即指令执行过程可能是3214或1324。

2、如果是volatile修饰的变量instance，会在语句3的前后各插入一个内存屏障