面試官最愛問的並發問題

來源：www.techug.com

在Java相關的崗位面試中，很多面試官都喜歡考察面試者對Java併發的瞭解程度，而以volatile關鍵字作為一個小的切入點，往往可以一問到底，把Java內存模型（JMM），Java併發編程的一些特性都牽扯出來，深入地話還可以考察JVM底層實現以及操作系統的相關知識。

1

關於Java併發,說說你對volatile關鍵字的理解

就我理解的而言，被volatile修飾的共享變量，就具有了以下兩點特性：

• 1.保證了不同線程對該變量操作的內存可見性;
• 2.禁止指令重排序

2

詳細說下什麼是內存可見性，什麼是重排序？

這個聊起來可就多了，我還是從Java內存模型說起吧。 Java虛擬機規範試圖定義一種Java內存模型（JMM）,來屏蔽掉各種硬件和操作系統的內存訪問差異，讓Java程序在各種平臺上都能達到一致的內存訪問效果。簡單來說，由於CPU執行指令的速度是很快的，但是內存訪問的速度就慢了很多，相差的不是一個數量級，所以搞處理器的那群大佬們又在CPU里加了好幾層高速緩存。

在Java內存模型裡，對上述的優化又進行了一波抽象。JMM規定所有變量都是存在主存中的，類似於上面提到的普通內存，每個線程又包含自己的工作內存，方便理解就可以看成CPU上的寄存器或者高速緩存。所以線程的操作都是以工作內存為主，它們只能訪問自己的工作內存，且工作前後都要把值在同步回主內存。

這麼說得我自己都有些不清楚了，拿張紙畫一下：

在線程執行時，首先會從主存中read變量值，再load到工作內存中的副本中，然後再傳給處理器執行，執行完畢後再給工作內存中的副本賦值，隨後工作內存再把值傳回給主存，主存中的值才更新。 使用工作內存和主存，雖然加快的速度，但是也帶來了一些問題。比如看下面一個例子：

i = i + 1;

假設i初值為0，當只有一個線程執行它時，結果肯定得到1，當兩個線程執行時，會得到結果2嗎？這倒不一定了。可能存在這種情況：

線程1： load i from 主存 // i = 0
 i + 1 // i = 1
線程2： load i from主存 // 因為線程1還沒將i的值寫回主存，所以i還是0
 i + 1 //i = 1
線程1: save i to 主存
線程2： save i to 主存

如果兩個線程按照上面的執行流程，那麼i最後的值居然是1了。如果最後的寫回生效的慢，你再讀取i的值，都可能是0，這就是緩存不一致問題。 下面就要提到你剛才問到的問題了，JMM主要就是圍繞著如何在併發過程中如何處理原子性、可見性和有序性這3個特徵來建立的，通過解決這三個問題，可以解除緩存不一致的問題。而volatile跟可見性和有序性都有關。

3.

可以具體說一說這三個特性嗎？

1.原子性(Atomicity)：

Java中，對基本數據類型的讀取和賦值操作是原子性操作，所謂原子性操作就是指這些操作是不可中斷的，要做一定做完，要麼就沒有執行。 比如：

i = 2;
j = i;i++;
i = i + 1;

上面4個操作中，i=2是讀取操作，必定是原子性操作，j=i你以為是原子性操作，其實吧，分為兩步，一是讀取i的值，然後再賦值給j,這就是2步操作了，稱不上原子操作，i++和i = i + 1其實是等效的，讀取i的值，加1，再寫回主存，那就是3步操作了。

所以上面的舉例中，最後的值可能出現多種情況，就是因為滿足不了原子性。 這麼說來，只有簡單的讀取，賦值是原子操作，還只能是用數字賦值，用變量的話還多了一步讀取變量值的操作。

有個例外是，虛擬機規範中允許對64位數據類型(long和double)，分為2次32為的操作來處理，但是最新JDK實現還是實現了原子操作的。 JMM只實現了基本的原子性，像上面i++那樣的操作，必須藉助於synchronized和Lock來保證整塊代碼的原子性了。線程在釋放鎖之前，必然會把i的值刷回到主存的。

2. 可見性(Visibility)：

說到可見性，Java就是利用volatile來提供可見性的。 當一個變量被volatile修飾時，那麼對它的修改會立刻刷新到主存，當其它線程需要讀取該變量時，會去內存中讀取新值。而普通變量則不能保證這一點。 其實通過synchronized和Lock也能夠保證可見性，線程在釋放鎖之前，會把共享變量值都刷回主存，但是synchronized和Lock的開銷都更大。

3. 有序性（Ordering）

JMM是允許編譯器和處理器對指令重排序的，但是規定了as-if-serial語義，即不管怎麼重排序，程序的執行結果不能改變。比如下面的程序段：

double pi = 3.14; //A
double r = 1; //B
double s= pi * r * r;//C 

上面的語句，可以按照A->B->C執行，結果為3.14,但是也可以按照B->A->C的順序執行，因為A、B是兩句獨立的語句，而C則依賴於A、B，所以A、B可以重排序，但是C卻不能排到A、B的前面。JMM保證了重排序不會影響到單線程的執行，但是在多線程中卻容易出問題。 比如這樣的代碼:

int a = 0;
bool flag = false;
public void write() {
 a = 2; //1
 flag = true; //2
 }
public void multiply() {
 if (flag) { //3
 int ret = a * a;//4
 }
}

假如有兩個線程執行上述代碼段，線程1先執行write，隨後線程2再執行multiply，最後ret的值一定是4嗎？結果不一定：

如圖所示，write方法裡的1和2做了重排序，線程1先對flag賦值為true，隨後執行到線程2，ret直接計算出結果，再到線程1，這時候a才賦值為2,很明顯遲了一步。 這時候可以為flag加上volatile關鍵字，禁止重排序，可以確保程序的有序性，也可以上重量級的synchronized和Lock來保證有序性,它們能保證那一塊區域裡的代碼都是一次性執行完畢的。

另外，JMM具備一些先天的有序性,即不需要通過任何手段就可以保證的有序性，通常稱為happens-before原則。<>定義瞭如下happens-before規則：

1.程序順序規則： 一個線程中的每個操作，happens-before於該線程中的任意後續操作

2.監視器鎖規則：對一個線程的解鎖，happens-before於隨後對這個線程的加鎖

3.volatile變量規則： 對一個volatile域的寫，happens-before於後續對這個volatile域的讀

4.傳遞性：

5.start()規則： 如果線程A執行操作ThreadB_start()(啟動線程B) , 那麼A線程的ThreadB_start()happens-before 於B中的任意操作

6.join()原則： 如果A執行ThreadB.join()並且成功返回，那麼線程B中的任意操作happens-before於線程A從ThreadB.join()操作成功返回。

7.interrupt()原則： 對線程interrupt()方法的調用先行發生於被中斷線程代碼檢測到中斷事件的發生，可以通過Thread.interrupted()方法檢測是否有中斷髮生

8.finalize()原則：一個對象的初始化完成先行發生於它的finalize()方法的開始

第1條規則，程序順序規則是說在一個線程裡，所有的操作都是按順序的，但是在JMM裡其實只要執行結果一樣，是允許重排序的，這邊的happens-before強調的重點也是單線程執行結果的正確性，但是無法保證多線程也是如此。

第2條規則，監視器規則其實也好理解，就是在加鎖之前，確定這個鎖之前已經被釋放了，才能繼續加鎖。

第3條規則，就適用到所討論的volatile，如果一個線程先去寫一個變量，另外一個線程再去讀，那麼寫入操作一定在讀操作之前。

第4條規則，就是happens-before的傳遞性。 後面幾條就不再一一贅述了。

4.

volatile關鍵字如何滿足併發編程的三大特性？

那就要重提volatile變量規則： 對一個volatile域的寫，happens-before於後續對這個volatile域的讀。 這條再拎出來說，其實就是如果一個變量聲明成是volatile的，那麼當我讀變量時，總是能讀到它的最新值，這裡最新值是指不管其它哪個線程對該變量做了寫操作，都會立刻被更新到主存裡，我也能從主存裡讀到這個剛寫入的值。也就是說volatile關鍵字可以保證可見性以及有序性。 繼續拿上面的一段代碼舉例：

int a = 0;
bool flag = false;
public void write() {
 a = 2; //1
 flag = true; //2 

 }
public void multiply() {
 if (flag) { //3
 int ret = a * a;//4
 }
}

這段代碼不僅僅受到重排序的困擾，即使1、2沒有重排序。3也不會那麼順利的執行的。假設還是線程1先執行write操作，線程2再執行multiply操作，由於線程1是在工作內存裡把flag賦值為1，不一定立刻寫回主存，所以線程2執行時，multiply再從主存讀flag值，仍然可能為false，那麼括號裡的語句將不會執行。 如果改成下面這樣：

int a = 0;
volatile bool flag = false;
public void write() {
 a = 2; //1
 flag = true; //2
 }
public void multiply() {
 if (flag) { //3
 int ret = a * a;//4
 }
}

那麼線程1先執行write,線程2再執行multiply。根據happens-before原則，這個過程會滿足以下3類規則：

程序順序規則：1 happens-before 2; 3 happens-before 4; (volatile限制了指令重排序，所以1 在2 之前執行)

volatile規則：2 happens-before 3

傳遞性規則：1 happens-before 4 當寫一個volatile變量時，JMM會把該線程對應的本地內存中的共享變量刷新到主內存 當讀一個volatile變量時，JMM會把該線程對應的本地內存置為無效，線程接下來將從主內存中讀取共享變量。

5.

volatile的兩點內存語義能保證可見性和有序性，但是能保證原子性嗎？

首先我回答是不能保證原子性，要是說能保證，也只是對單個volatile變量的讀/寫具有原子性，但是對於類似volatile++這樣的複合操作就無能為力了，比如下面的例子：

public class Test {
 public volatile int inc = 0;
 
 public void increase() {
 inc++;
 }
 
 public static void main(String[] args) {
 final Test test = new Test();
 for(int i=0;i<10;i++){
 new Thread(){
 public void run() {
 for(int j=0;j<1000;j++)
 test.increase();
 };
 }.start();
 } 

 
 while(Thread.activeCount()>1) //保證前面的線程都執行完
 Thread.yield();
 System.out.println(test.inc);
 }

按道理來說結果是10000，但是運行下很可能是個小於10000的值。有人可能會說volatile不是保證了可見性啊，一個線程對inc的修改，另外一個線程應該立刻看到啊！可是這裡的操作inc++是個複合操作啊，包括讀取inc的值，對其自增，然後再寫回主存。

假設線程A，讀取了inc的值為10，這時候被阻塞了，因為沒有對變量進行修改，觸發不了volatile規則。 線程B此時也讀讀inc的值，主存裡inc的值依舊為10，做自增，然後立刻就被寫回主存了，為11。 此時又輪到線程A執行，由於工作內存裡保存的是10，所以繼續做自增，再寫回主存，11又被寫了一遍。所以雖然兩個線程執行了兩次increase()，結果卻只加了一次。

有人說，volatile不是會使緩存行無效的嗎？但是這裡線程A讀取到線程B也進行操作之前，並沒有修改inc值，所以線程B讀取的時候，還是讀的10。

又有人說，線程B將11寫回主存，不會把線程A的緩存行設為無效嗎？但是線程A的讀取操作已經做過了啊，只有在做讀取操作時，發現自己緩存行無效，才會去讀主存的值，所以這裡線程A只能繼續做自增了。

綜上所述，在這種複合操作的情景下，原子性的功能是維持不了了。但是volatile在上面那種設置flag值的例子裡，由於對flag的讀/寫操作都是單步的，所以還是能保證原子性的。 要想保證原子性，只能藉助於synchronized,Lock以及併發包下的atomic的原子操作類了，即對基本數據類型的 自增（加1操作），自減（減1操作）、以及加法操作（加一個數），減法操作（減一個數）進行了封裝，保證這些操作是原子性操作。

6.

volatile底層的實現機制是什麼？

如果把加入volatile關鍵字的代碼和未加入volatile關鍵字的代碼都生成彙編代碼，會發現加入volatile關鍵字的代碼會多出一個lock前綴指令。 lock前綴指令實際相當於一個內存屏障，內存屏障提供了以下功能： 1.重排序時不能把後面的指令重排序到內存屏障之前的位置 2.使得本CPU的Cache寫入內存 ** **3.寫入動作也會引起別的CPU或者別的內核無效化其Cache，相當於讓新寫入的值對別的線程可見。

7.

你在哪裡會使用到volatile，舉兩個例子呢？

1.狀態量標記

就如上面對flag的標記，我重新提一下：

int a = 0;
volatile bool flag = false;
public void write() {
 a = 2; //1
 flag = true; //2
}
public void multiply() {
 if (flag) { //3
 int ret = a * a;//4
 }
}

這種對變量的讀寫操作，標記為volatile可以保證修改對線程立刻可見。比synchronized,Lock有一定的效率提升。

2.單例模式的實現，典型的雙重檢查鎖定（DCL）

class Singleton{
 private volatile static Singleton instance = null;
 
 private Singleton() {
 
 }
 
 public static Singleton getInstance() {
 if(instance==null) {
 synchronized (Singleton.class) {
 if(instance==null) 

 instance = new Singleton();
 }
 }
 return instance;
 }
}

這是一種懶漢的單例模式，使用時才創建對象，而且為了避免初始化操作的指令重排序，給instance加上了volatile。

擴展閱讀

Java併發面試題精選

JAVA多線程和併發基礎面試問答

Java併發編程之volatile關鍵字解析

閱讀更多 程序員之言 的文章

關鍵字: FLAG 內存 排序