volatile关键字的作用

1.线程可见

​ 如果多个线程都使用了同一个变量，那么其中一个线程改变了该变量，其他线程都会读取到该变量的最新值。

2.防止指令重排序

线程可见测试案例：

volatile关键字可以线程读取变量的值时保证该值一定是最新值。

java环境：

D:\WS-TEST>java -version
java version "1.8.0_151"
Java(TM) SE Runtime Environment (build 1.8.0_151-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.151-b12, mixed mode)
    
###jvm的server环境和client环境会对结果有影响，如果测试过程中结论不正确，请更改为server版本

测试代码：

public class TestClass   {    
    static  int num = 0;
    public static void main(String[] args) throws Exception{
        //线程1
        new Thread(() -> {
            while(true) {
                if(num >= 3) {
                    System.out.println("终止循环num最新值=" + num);
                    break;
                }
            }
        }).start();
       //线程2
        new Thread(() -> {
            while(num < 6) {
                num++;
                System.out.println("改变num值为:" + num); 
                try {
                    Thread.sleep(100 );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
}

打印结果：

改变num值为:1
改变num值为:2
改变num值为:3
改变num值为:4
改变num值为:5
改变num值为:6

可见线程2改变num值后线程1并未察觉到。导致线程1一致处于死循环

修改为static volatile int num = 0;后

打印结果

改变num值为:1
改变num值为:2
改变num值为:3
终止循环num最新值=3
改变num值为:4
改变num值为:5
改变num值为:6

线程2改变num后线程1终止循环，和我们预期的是一样的。

volatile保证线程可见的原理：

摘自：https://www.lagou.com/lgeduarticle/78722.html

Java内存模型定义了线程和主内存之间的抽象关系，具体如下。

• 共享变量存储于主内存之中，每个线程都可以访问。

• 每个线程都有私有的工作内存和本地内存。

• 工作内存值存储该线程对共享变量的副本。

• 线程不能直接操作主内存，只有先操作了工作内存之后才能写入主内存。

• 工作内存和Java内存模型一样也是一个抽象的概念，它其实并不存在，它涵盖了缓存、寄存器、编译优化以及硬件等。

  image

也就是说线程2将变量改变后写回主内存时，会让所有线程的工程内存中该变量副本置为无效，那么其他线程再次读取变量副本时由于副本时无效的会从主内存中重新读取，从而达到读取到最新值的效果。

volatile可以防止指令重排序

摘自：https://www.cnblogs.com/dolphin0520/p/3920373.html#!comments

有序性：即程序执行的顺序按照代码的先后顺序执行。举个简单的例子，看下面这段代码：

int i =  0 ;        
boolean flag =  false ;
i = 1 ;         //语句1 
flag =  true ;  //语句2

上面代码定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序（Instruction Reorder）。

下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证的呢？再看下面一个例子：

int a = 10 ;   //语句1 
int r =  2 ;   //语句2 
a = a +  3 ;   //语句3 
r = a*a;       //语句4

这段代码有4个语句，那么可能的一个执行顺序是：

img

那么可不可能是这个执行顺序呢： 语句2 语句1 语句4 语句3

不可能，因为处理器在进行重排序时是会考虑指令之间的数据依赖性，如果一个指令Instruction 2必须用到Instruction 1的结果，那么处理器会保证Instruction 1会在Instruction 2之前执行。

虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢？下面看一个例子：

//线程1:
context = loadContext(); //语句1
inited =  true ;        //语句2
//线程2:
while (!inited ){ 
  sleep() 
} 
doSomethingwithconfig(context);

上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。

从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。

也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。