深刻理解volatile关键字

　　1.volatile与可见性

　　都知道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了。