面试必备系列JUC(1)--volitale 超详解

面试必备系列JUC(1)--volitale 超详解

田伯光：令狐兄，近日我翻阅JUC书籍的时候，对于volitale关键字颇有些心得，不知今日可否探讨一二？

令狐冲：田兄太客气了，那今日我们便在此处比划比划。田兄先说下你对volitale的理解吧。

田伯光：volatile是Java juc（java.util.concurrent）提供的一种轻量级的同步机制。相比于synchronized（synchronized通常称为重量级锁，之后的文章会有讲述），volatile更轻量级，因为它不会引起线程上下文的切换和调度。并且使用volitale关键字，可以保证可见性、不保证原子性、禁止指令重排序！

part1：可见性

令狐冲：哦？没想到田兄还有如此造诣，那田兄能否说下为何volitale可以保证可见性呢？

田伯光：所谓可见性，其实就是：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看到修改的值。

田伯光：这个证明比较简单，先看下代码示例吧：

//线程1
boolean OK = false;
while(!OK){
    doSomething();
}
 
//线程2
OK = true;

现在我先让线程1先执行，线程2后执行。这段代码很经典，很多人在中断线程时可能都会采用这种标记方法。令狐兄，你觉得这段代码中的while循环体会被中断吗？

令狐冲：当然会了田兄，我的想法和大家一样。

田伯光：错了！其实答案是不一定！也许在大多数时候，这个代码能够把线程中断，但是也有可能会导致无法中断线程，别急，我来告诉你原因！

田伯光：在前面你和小仪琳师父已经讨论过了，每个线程在运行过程中都会有自己的工作内存，这里也不例外， 线程1在运行的时候，也会将stop变量的值拷贝一份放在自己的工作内存当中。
但是，如果线程2更改了OK变量的值之后，但是还没来得及写入主存当中，线程2上的cpu分片就转去做其他事情了，那么线程1由于不知道线程2对OK变量的更改，所以还会一直循环下去。

令狐冲：原来是这样！难道使用volitale之后，结果就不一样了嘛？

田伯光：当然了，一共有三处不同：
一：使用volatile关键字会强制将修改的值立即写入主存；
二：使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量ok的缓存行无效。
三：由于线程1的工作内存中缓存变量ok的缓存行无效，所以线程1再次读取变量stop的值时会去主存读取。

田伯光：所以线程1读取到的就是最新的正确的值。令狐兄下次写代码的时候一定要用上呀！

part2： 不保证原子性

令狐冲：那田兄是否能继续说下为什么volitale不能保证原子性呢， 我对此特性颇有疑惑。

田伯光：哼，那你可要记清楚了，上次去工牌场面试的时候，面试官还问我了！
所谓原子性，见名知意，就是不可分割、完整性，即某个线程正在进行某个任务的时候，中间不可以被加塞或者被分割，需要整体完整，要么同时成功，要么同时失败。

看下这个示例：

public class TestAtomicity {
    public volatile int variable = 0;
    //一个自增方法
    public void add() {
        variable++;
    }
     
    public static void main(String[] args) {
        final TestAtomicity testAtoc = new TestAtomicity();
        for(int i=0;i<20;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<500;j++)
                        testAtoc.add();
                };
            }.start();
        }
         
        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(testAtoc.variable);
    }
}

田伯光：令狐兄觉得这段程序的输出结果是几？

令狐冲：愚弟觉得这结果肯定是10000。不知对不对？

田伯光：你确实愚了，事实上运行它会发现每次运行结果都不一致，都是一个小于10000的数字。

令狐冲：田兄，不对呀，上面是对变量variable进行自增操作，你前面说了，由于volatile保证了可见性，那么在每个线程中对variable自增完之后，在其他线程中都能看到修改后的值啊，所以有20个线程分别进行了500次操作，那么最终varible的值应该是500*20=10000呀？

田伯光：令狐兄，其实你走进了为兄给你设置的误区了！ volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。

令狐冲：小弟愚钝，还请田兄仔细讲解！!

田伯光：令狐兄，上面的自增操作是不具备原子性的（add方法），它包括读取变量variable的原始值、将取出来的variable进行加1操作、再将varible写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行，就有可能导致下面这种情况出现：

田伯光：假如某个时刻变量varible的值为100，如果线程1对变量varible进行自增操作，线程1先读取了变量varibel的原始值，紧接着线程1被阻塞了（cpu分片轮转走了！）；

田伯光：此时如果线程2恰好也对变量varible进行自增操作，线程2也去读取变量varible的原始值，由于线程1只是对变量varible进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量varible的缓存行无效，所以线程2会直接去主存读取varible的值，发现varible的值时100，然后进行加1操作，并把101写入工作内存，最后写回主存。

田伯光：如果 cpu分片此时又轮转到了线程1，线程1从阻塞状态恢复过来，然后线程1接着进行加1操作，由于已经读取了varible的值（不会再次从内存中重新读取），注意此时在线程1的工作内存中varible的值仍然为100，所以线程1对varible进行加1操作后inc的值为101，然后将101写入工作内存，最后写回主存。

令狐冲：那么两个线程分别进行了一次自增操作后，varible变量的值只增加了1 !!

田伯光：是的，说明你悟了！

令狐冲：不对呀田兄，前面不是说保证一个变量在修改volatile变量时，会让缓存行无效吗？然后其他线程去读就会读到新的值，这样不就解释不通了吗？

田伯光：对，你说的没错，就是我上次给你说过的happen-before规则中的volitale变量规则。但是你要注意的是，线程1做了读取了varible的原始值这个操作之后，它就被阻塞了！并没有对varible的值进行修改！ 虽然volatile能保证线程2对变量varible的值读取是从内存中读取的，但是线程1还没有对varible的值进行修改呀，所以线程2根本就不会看到修改的值。

田伯光：所以问题的根源就在这里，自增操作不是原子性操作，volatile也无法保证对变量的任何操作都是原子性的。之前有面试官问过我，我都答上来了！哼！

令狐冲：田兄还是厉害呀，这个知识点我get 了，不知道代码怎么改才能达到想要的数字10000呢？
田伯光：我先告诉你有几种方法吧，加上synchronized关键字、采用Lock锁、使用AtomicInteger都可以做到，后面有机会我再告诉你吧，现在先言归正传！
在这里插入图片描述

part3：禁止指令重排序

田伯光： 令狐兄，要不我连volitale能禁止指令重排序一块都说了吧，省得你还得问。

令狐冲：多谢田兄指点，小弟愿洗耳恭听。

田伯光：volatile关键字能禁止指令重排序，所以 volatile能在一定程度上保证有序性。记住，是一定程度，而不是全部！！这个很重要！！

volatile关键字禁止指令重排序有两层意思：

1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。
　　
令狐冲：嗯。。嗯。田兄说的比较绕，能不能举个简单的例子？

田伯光：好吧，你看下边这个例子：

	//x、y为非volatile变量
	//flag为volatile变量
	x = 2;       	 //语句1
	y = 0;       	 //语句2
	fag = true; 	 //语句3
	x = 4;        	 //语句4
	y = -1;       	//语句5

田伯光：由于fag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。但是令狐兄，你要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。

田伯光：并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

那么我们再举一个例子：

//线程1:
cont = getContext();   //语句1
begin = true;          //语句2
 
//线程2:
while(!begin ){
  sleep()
}
doSomethingwithconfig(cont);

田伯光：其实在真正执行的时候，经过编译器的优化，有可能语句2会在语句1之前执行，那么这就可能造成context还没被初始化，而线程2中就使用未初始化的context去进行操作，这样必然导致程序出错。

令狐冲：那这里如果用volatile关键字对begin变量进行了修饰，就不会出现这种问题了吧？因为当执行到语句2时，必定能保证context已经初始化完毕。

田伯光：嗯，就是这样子！看样你已经知道了啥是禁止指令重排序了！

part4：volatile的原理和实现机制

令狐冲：田兄前面讲述了源于volatile关键字的一些使用，听的似懂非懂，下面我们来探讨一下volatile到底如何保证可见性和禁止指令重排序的吧。

田伯光：我之前读过一本秘籍，《深入理解Java虚拟机》，书中有一句话我印象很深刻：

“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”

田伯光：lock前缀指令实际上相当于一个内存屏障（也被称为内存栅栏），内存屏障会提供3个功能：

1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；　　
2）它会强制将对缓存的修改操作立即写入主存；
3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

令狐冲：这样就告诉了编译器和CPU,不管什么指令都不能和这条Memeory Barrier指令重排顺序。并且内存屏障还会强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取都这些数据的最新版本。

part5：你在哪些地方用过volatile

令狐冲：田兄，我面试的时候，老是被问到volitale你平时再哪些场景用到过？ 我都回答不出来。。。

田伯光：这个很正常，面试官想看看你的实际运用能力怎么样，怕你只会背八股文。。我说几个场景，你记清楚了！

第一个， 状态标志
volatile变量用于状态标志，用于指示一个重要的一次性事件，如完成初始化或请求停机。

	volatile boolean shutdownRequested;  
	public void shutdown() {   
	    shutdownRequested = true;   
	}  
	public void doWork() {   
	    while (!shutdownRequested) {   
	        // 代码业务逻辑  
	    }  
	}

分析： 线程A执行doWork()的逻辑代码时，线程B调用了shutdown()方法，线程A立即停止运行while中的逻辑代码。

第二个：一次性发布
在缺乏同步的情况下，可能遇到某个对象引用的更新值（由另一个线程写入）和该对象状态的旧值同时存在。例如双重检验锁单例DCL。

public class Singleton{
    private volatile static Singleton uniqueInstance;
    private Singleton(){
    }
    public static Singleton getUniqueInstance(){
        if(uniqueInstance == null){                   // 1)
            synchronized(Singleton.class){            
                if(uniqueInstance == null){           // 2)
                    uniqueInstance = new Singleton(); // 3)
                }
            }
        }
        return uniqueInstance;
    }
    public static void main(String[] args){
        Singleton.getUniqueInstance();
    }
}

分析： 线程A运行到 2) 处获得同步锁，uniqueInstance==null运行 3) 创建对象，JVM分 3 步（实际是对象创建的5步）运行的，
① 为 uniqueInstance 分配内存空间；
② 初始化 uniqueInstance；
③ 将 uniqueInstance 指向分配的内存空间；
若没有用volatile修饰，JVM进行了指令重排，执行了 ① -> ③，但还没有执行初始化 ② ，此时线程B执行getUniqueInstance()发现uniqueInstance不为null，便返回还没有初始化的uniqueInstance对象，出现错误。即线程A执行 3) 时 ① -> ③ 状态下未初始化的对象（旧值）和执行完 3) ① -> ③ -> ② 状态下初始化后的对象（新值）同时存在。

PS：对象创建过程： 类加载检查 -> 为对象分配内存 -> 将分配的内存空间（不包括对象头）初始化置零 -> 设置对象头信息 -> 执行init()按照用户定义的构造函数进行初始话。

第三个：开销较低的“读-写锁”策略
如果读操作远远超过了写操作，可以结合内部锁和volatile变量来减少公共代码路径的开销。 例如线程安全的计数器，使用synchronized确保增量操作的原子性，并使用volatile保证当前结果的可见性。如果更新不频繁，该方法可以实现更好的性能。因为读开销仅仅涉及volatile操作，优于一个无竞争的锁的开销。

public class CheesyCounter {  
    private volatile int value;  
    //读操作，没有synchronized，提高性能  
    public int getValue() {   
        return value;   
    }   
    //写操作，必须synchronized。因为x++不是原子操作  
    public synchronized int increment() {  
        return value++;  
    }  
}

令狐冲：感谢田兄指点，volitale所有的知识点我都知道了！

part6：volitale面试常问问题和内推码

1.请你谈谈volatile的工作原理
2.Volatile的禁止指令重排序有什么意义?synchronied怎么用?
3.volatile 的原子性问题?为什么i++ 这种不支持原子性?从计算机原理的设计来讲下不能保证原子性的原因
4.volatile 是什么？
5.JMM与volatile有什么关系？
6.什么是可见性？什么是不保证原子性？指令重排请你说说？
7.知道什么是内存屏障吗？说说

===================================================
字节内推：
字节内推〉字节校招开启。简历砸过来！！！！！！！
200多个岗位，地点：北京 上海 广州 杭州 成都 深圳。。

字节师兄内推码：B1RHWFK
官网校招简历投递通道：https://jobs.toutiao.com/campus/m/position?referral_code=B1RHWFK

===================================================
微信公众号：猿侠令狐冲