深入理解volatile关键字

1.volatile与可见性

我们提供的服务有：成都做网站、网站建设、微信公众号开发、网站优化、网站认证、金州ssl等。为上千企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的金州网站制作公司

都知道volatile可以保证可见性，那么到底是如何保证的呢?

这便于Happen-before原则有关，该原则的第三条规定：对一个volatile修饰的变量，写操作要早于对这个变量的读操作。具体步骤如下：

A线程将共享变量读进工作内存中，同时B线程也将共享变量读进工作内存中。

在A线程对共享变量修改后，会立即刷新到主内存，此时B线程的工作内存中的共享变量就会被设置无效，需要从主内存中重新读取新值。反映到硬件上就是CPU的Cache line 置为无效状态。

这样便保证了可见性，简单而言，就是线程在对volatile修饰的变量修改且刷新到主内存之后，会使得其它线程的工作内存中的共享变量无效，需要从主内存中再此读取。

2.volatile与有序性

都知道volatile可以保证有序性，那么到底是如何保证的呢?

volatile保证有序性，比较直接，禁止JVM和处理器对volatile关键字修饰的变量进行指令重排序，但对于该变量之前或者之后的可以任意排序，只要最终的结果与没更改前的结果保持一致即可。

底层原理

被volatile修饰的变量在底层会加一个“lock:”的前缀，带"lock"前缀的指令相当于一个内存屏障，这恰恰是保证可见性与有序性的关键，该屏障的作用主要有一下几点：

指令重排时，屏障前的代码不能重排到屏障后，屏障后的也不能重排到屏障前。

执行到内存屏障时，确保前面的代码都已经执行完毕，且执行结果是对屏障后的代码可见的。

强制将工作内存中的变量刷新到主内存。

其它线程的工作内存的变量会设置无效，需要重现从主内存中读取。

3.volatile与原子性

都知道volatile不能保证原子性，那么为何不能保证原子性呢?

代码演示：

package com.github.excellent01;

import java.util.concurrent.CountDownLatch;

/**

* @auther plg

* @date 2019/5/19 9:37

*/

public class TestVolatile implements Runnable {

private volatile Integer num = 0;

private static CountDownLatch latch = new CountDownLatch(10);

@Override

public void run() {

for(int i = 0; i < 1000; i++){

num++;

}

latch.countDown();

}

public Integer getNum() {

return num;

}

public static void main(String[] args) throws InterruptedException {

TestVolatile test = new TestVolatile();

for(int i = 0; i < 10; i++){

new Thread(test).start();

}

latch.await();

System.out.println(test.getNum());

}

}

启动10个线程，每个线程对共享变量num，加1000次，当所有的线程执行完毕之后，打印输出num 的最终结果。

很少有10000的这便是因为volatile不能保证原子性造成的。

原因分析：

num++的操作由三步组成：

从主内存将num读进工作内存中

在工作内存中进行加一

加一完成后，写回主内存。

虽然这三步都是原子操作，但合起来不是原子操作，每一步执行的过程中都有可能被打断。

假设此时num的值为10，线程A将变量读进自己的工作内存中，此时发生了CPU切换，B也将num读进自己的工作内存，此时值也是10.B线程在自己的工作内存中对num的值进行修改，变成了11，但此时还没有刷新到主内存，因此A线程还不知道num的值已经发生了改变，之前所说的，对volatile变量修改后，其它线程会立即得知，前提也是要先刷新到主内存中，这时，其它线程才会将自己工作中的共享变量的值设为无效。因为没有刷新到主内存，因此A傻傻的不知道，在10的基础上加一，因此最终虽然两个线程都进行了加一操作，但最终的结果只加了一次。

这便是为什么volatile不能保证原子性。

volatile的使用场景

根据volatile的特点，保证有序性，可见性，不能保证原子性，因此volatile可以用于那些不需要原子性，或者说原子性已经得到保障的场合：

代码演示

volatile boolean shutdownRequested

public void shutdown() {

shutdownRequested = true;

}

public void work() {

while(shutdownRequested) {

//do stuff

}

}

只要线程对shutdownRequested进行修改，执行work的线程会立即看到，因此会立即停止下来，如果不加volatile的话，它每次去工作内存中读取数据一直是个true，一直执行，都不知道别人已经让它停了。

代码演示：无锡看妇科哪里好 http://www.xasgfk.cn/

package com.github.excellent;

import java.util.concurrent.ThreadPoolExecutor;

/**

* 启动线程会被阻塞，flag 从内存读入，会存入寄存器中，下次直接从寄存器取值

* 因此值一直是false

* 即使别的线程已经将值更改了，它也不知道

* 加volatile即可。也可以加锁，只要保证内存可见性即可

* @auther plg

* @date 2019/5/2 22:40

*/

public class Testvolatile {

public static boolean flag = false;

public static void main(String[] args) throws InterruptedException {

Thread thread1 = new Thread(()->{

for(;;) {

System.out.println(flag);

}

});

Thread thread2 = new Thread(()->{

for(;;){

flag = true;

}

});

thread1.start();

Thread.sleep(1000);

thread2.start();

}

}

执行结果：

加一个volatile就ok了。