volatile可见性的一些认识和论证

Posted 2020-10-04 热心市民小陈

一、前言

　　　　volatile的关键词的使用在JVM内存模型中已是老生常谈了，这篇文章主要结合自己对可见性的一些认识和一些直观的例子来谈谈volatile。文章正文大致分为三部分，首先会介绍一下happen-before,接着讲解volatile的一些使用场景，最后会附上一些例子来论证使用与不使用volatile的区别。

 

 

二、happen-before

　　　　对操作系统有认识的同学一定知道，CPU一般有三级缓存，在与内存交互的时候，存在缓存与内存的更新问题，其次CPU在读取指令的时候，会做一些指令重排序的工作，提高程序运行效率。类比JVM内存模型（见下图），每个线程拥有自己的工作内存，同时存在一个主存，线程间通过主存来进行通信，同样的，JVM也存在指令重排序，可见JVM内存模型与实际物理内存模型十分相似。（这里顺便提一下，编译器其实也会作一定重排序优化）。

　　　　

　　　　作为开发人员，你不可能了解到每个JVM优化细节，更不可能了解到CPU何时会进行指令重排序，所以java语言定义了更上层的一个概念，就是"happen-before"。起初，我看到这个单词的时候，误以为这是一个指令执行顺序的规则，后来仔细想想又发觉不对劲。如果”happen-before“仅仅是抽象了指令执行顺序的概念，那么它就把握不了“工作内存将值写回主存”和“工作内存从主存中刷新自己的值”这个两个action的时机。那么这个概念也就变得没什么意义了。所以！所以！所以！”happen-before“是一个可见性的原则！！！

下面给出happen-before的具体规则：

程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；
锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；
volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；
传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；
线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；
线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；
对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

 

　　　　

三、volatile的使用场景

　　　　happen-before的第三条规则提到“volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作”，也就是说；一个volatile变量的写操作对后续对读操作可见。说白了就是每次写完volatile变量，都会将值从工作内存写回到主存中去，每次读取volatile变量，工作内存必须从主存中刷新下自己的值。如此的话，volatile就是为了解决多个线程共享数据的可见性问题。但是不是任何数据共享场景都可以使用volatile，必须满足以下两种情景才行。

　　　　应用场景：

　　　　1.多个线程不依赖原值的情况下进行读写操作

　　　　2.一个线程依赖原值进行写操作，多个线程进行读操作

在我看来，除了这两种情况外，无非是多个线程依赖原值进行运算，这样子倒不是说volatile可见性不起作用了，而是无法保证读取原值和运算是一个原子操作！举个简单的例子，多个线程执行i++;i是一个共享变量，由于读取i的值和i自增不是一个原子操作，所以i最终会丢失掉一部分自增过程。代码如下，最终i输出的结果是一个小于1000的整数。

/**
 * Created by chenqimiao on 17/8/23.
 */
public class Testv {
    public static volatile int i = 0;
    public static void main(String args[]){
        for (int i =0;i<1000;i++){
            new Thread(){
                public void run(){
                    Thread.yield();
                    Testv.i++;
                }
            }.start();
        }
        System.out.println(Testv.i);

    }
}

要满足以上这种需求，我们还必须赋予代码原子性，最常用的肯定是锁操作了，一个字稳，性能可观，同时保证原子性和可见性。如果想操作一波的话，还可以考虑使用一些无锁操作，如CAS，象java.util.concurrent包下的一些原子类就是利用了CAS来做到原子性，但原子性并不能保证可见性，这个时候，还需要配合volatile。

以上种种都是对volatile使用场景的概括，想了解具体的使用场景可以参考博文:https://www.ibm.com/developerworks/cn/java/j-jtp06197.html

 

四、volatile可见性的证明

　　　先上段代码好了，不知道从何说起了。

　　

package com.example.demo.netty;

/**
 * Created with IntelliJ IDEA.
 * User: chenqimiao
 * Date: 2017/8/23
 * Time: 9:16
 * To change this template use File | Settings | File Templates.
 */
public class VolatileTest {

     boolean isStop = false;

    public void test(){
        Thread t1 = new Thread(){
            public void run() {
                isStop=true;
            }
        };
        Thread t2 =  new Thread(){
            public void run() {
                while (!isStop);
            }
        };

        t2.start();
        t1.start();

    }
    public static void main(String args[]) throws InterruptedException {
        for (int i =0;i<25;i++){
            new VolatileTest().test();
        }

    }
}

　　　　上面这段代码可能永远也不会结束，因为线程一对isStop的赋值，线程二可能对此并不可见。当然只是可能，所以为了放大可见性问题，我这里作了25次循环。只要有一组线程，“线程一对isStop的赋值,线程二对此不可见”的情况发生，就不会退出程序。

　　　　now，假如你给 isStop 添加一个 volatile 关键字，那么你会发现程序立马就会退出。