Java 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的作用，那么看下下面的例子可以看出volatile在实际中的作用

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

　　1、状态标记量

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

public class ServerHandler {

    　　private volatile isopen;

    　　public void run() {
       　　
        if (isopen) {

            //促销逻辑
            　　
        } else {

           //正常逻辑
            　　
        }
        　　
    }

    public void setIsopen(boolean isopen) {

       this.isopen = isopen
        　　
    }    　　
}

上述一个简单的案例我们可以清楚的看到，现实场景中用户执行了多线程中run()方法，如果需要开启促销逻辑，那么只需要后台设置调用setIsopen(true) 方法，就能很好的控制多线程中方法控制的问题了，该放说明volatile关键字的作用就是告诉该执行方法时时获取最新变量值。

　如何保证内存可见性?

　　在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的前后各插入一个内存屏障。