Java 之 volatile 詳解

 Volatile能夠看作是輕量級的 Synchronized，它只保證了共享變量的可見性。在線程 A 修改被 volatile 修飾的共享變量以後，線程 B 可以讀取到正確的值。 java 在多線程中操做共享變量的過程當中，會存在指令重排序與共享變量工做內存緩存的問題。

java 內存模型

Java內存模型規定了全部的變量都存儲在主內存中。每條線程中還有本身的工做內存，線程的工做內存中保存了被該線程所使用到的變量（這些變量是從主內存中拷貝而來）。線程對變量的全部操做（讀取，賦值）都必須在工做內存中進行。不一樣線程之間也沒法直接訪問對方工做內存中的變量，線程間變量值的傳遞均須要經過主內存來完成。

併發編程的三大概念

可見性

可見性是一種複雜的屬性，由於可見性中的錯誤老是會違背咱們的直覺。一般，咱們沒法確保執行讀操做的線程能適時看到其餘線程寫入的值，有時甚至是根本不可能的事情。爲了確保多個線程之間對內存寫入操做的可見性，必須使用同步機制。

可見性，是指線程之間的可見性，一個線程修改的狀態對另外一個線程是可見的。也就是線程修改的結果。

另外一個線程立刻就能看到。好比：用volattitle修飾的變量，就會具備可見性。volatile修飾的變量不容許線程內部緩存和重排序，即直接修改內存。因此對其餘線程是可見的。可是這裏須要注意一個問題，volatile只能讓他修飾內容具備可見性，但不能保證他具備原子性。好比 volatile int a = 0；以後有一個操做 a++；這個變量a具備可見性，可是a++ 依然是一個非原子操做，也就是這個操做一樣存在線程安全問題。

而普通的共享變量不能保證可見性，由於普通共享變量被修改以後，何時被寫入主存是不肯定的，當其餘線程去讀取時，此時內存中可能仍是原來的舊值，所以沒法保證可見性。

在 Java 中經過synchronized和Lock也可以保證可見性，synchronized和Lock能保證同一時刻只有一個線程獲取鎖而後執行同步代碼，而且在釋放鎖以前會將對變量的修改刷新到主存當中。所以能夠保證可見性。

原子性

原子是世界上的最小單位，具備不可分割性。原子性：即一個操做或者多個操做 要麼所有執行而且執行的過程不會被任何因素打斷，要麼就都不執行。在Java中，對基本數據類型的變量的讀取和賦值操做是原子性操做，即這些操做是不可被中斷的，要麼執行，要麼不執行。

好比 a=0；（a非long和double類型） 這個操做是不可分割的，那麼咱們說這個操做時原子操做。再好比：a++； 這個操做實際是a = a + 1；是可分割的，因此他不是一個原子操做。非原子操做都會存在線程安全問題，須要咱們使用同步技術（sychronized）來讓它變成一個原子操做。一個操做是原子操做，那麼咱們稱它具備原子性。java的concurrent包下提供了一些原子類，咱們能夠經過閱讀API來了解這些原子類的用法。好比：AtomicInteger、AtomicLong、AtomicReference等。

Java內存模型只保證了基本讀取和賦值是原子性操做，若是要實現更大範圍操做的原子性，能夠經過synchronized和Lock來實現。因爲synchronized和Lock可以保證任一時刻只有一個線程執行該代碼塊，那麼天然就不存在原子性問題了，從而保證了原子性。

有序性

有序性就是程序執行的順序按照代碼的前後順序執行。

什麼是指令重排序，通常來講，處理器爲了提升程序運行效率，可能會對輸入代碼進行優化，它不保證程序中各個語句的執行前後順序同代碼中的順序一致，可是它會保證程序最終執行結果和代碼順序執行的結果是一致的。指令重排序不會影響單個線程的執行，可是會影響到線程併發執行的正確性。也就是說，要想併發程序正確地執行，必需要保證原子性、可見性以及有序性。只要有一個沒有被保證，就有可能會致使程序運行不正確。

在Java內存模型中，容許編譯器和處理器對指令進行重排序，可是重排序過程不會影響到單線程程序的執行，卻會影響到多線程併發執行的正確性。

在Java裏面，能夠經過volatile關鍵字來保證必定的「有序性」。另外能夠經過synchronized和Lock來保證有序性，很顯然，synchronized和Lock保證每一個時刻是有一個線程執行同步代碼，至關因而讓線程順序執行同步代碼，天然就保證了有序性。

另外，Java內存模型具有一些先天的「有序性」，即不須要經過任何手段就可以獲得保證的有序性，這個一般也稱爲 happens-before 原則。若是兩個操做的執行次序沒法從happens-before原則推導出來，那麼它們就不能保證它們的有序性，虛擬機能夠隨意地對它們進行重排序。

volatile 原理

java 語言提供了一種稍弱的同步機制，Volatile能夠看作是輕量級的 Synchronized，即volatile變量，用來將變量的更新操做通知到其餘線程。當把變量聲明爲volatile類型後，編譯器與運行時都會注意到這個變量是共享的，所以不會將該變量上的操做與其餘內存操做一塊兒重排序。volatile變量不會被緩存在寄存器或者對其餘處理器不可見的地方，所以在讀取volatile類型的變量時總會返回最新寫入的值。

在訪問volatile變量時不會執行加鎖操做，所以也就不會使執行線程阻塞，所以volatile變量是一種比sychronized關鍵字更輕量級的同步機制。

當對非 volatile 變量進行讀寫的時候，每一個線程先從內存拷貝變量到CPU緩存中。若是計算機有多個CPU，每一個線程可能在不一樣的CPU上被處理，這意味着每一個線程能夠拷貝到不一樣的 CPU cache 中。

　　而聲明變量是 volatile 的，JVM 保證了每次讀變量都從內存中讀，跳過 CPU cache 這一步。

volatile做用

1.volatile可見性

一旦一個共享變量（類的成員變量、類的靜態成員變量）被volatile修飾以後，那麼就具有了兩層語義：

1）保證了不一樣線程對這個變量進行操做時的可見性，即一個線程修改了某個變量的值，這新值對其餘線程來講是當即可見的。

2）禁止進行指令重排序。

//線程1boolean stop = false;while(!stop){ doSomething();}//線程2stop = true;複製代碼

這段代碼是很典型的一段代碼，不少人在中斷線程時可能都會採用這種標記辦法。可是事實上，這段代碼會徹底運行正確麼？即必定會將線程中斷麼？不必定，也許在大多數時候，這個代碼可以把線程中斷，可是也有可能會致使沒法中斷線程（雖然這個可能性很小，可是隻要一旦發生這種狀況就會形成死循環了）。

下面解釋一下這段代碼爲什麼有可能致使沒法中斷線程。在前面已經解釋過，每一個線程在運行過程當中都有本身的工做內存，那麼線程1在運行的時候，會將stop變量的值拷貝一份放在本身的工做內存當中。

那麼當線程2更改了stop變量的值以後，可是還沒來得及寫入主存當中，線程2轉去作其餘事情了，那麼線程1因爲不知道線程2對stop變量的更改，所以還會一直循環下去。

可是用volatile修飾以後就變得不同了：

第一：使用volatile關鍵字會強制將修改的值當即寫入主存；

第二：使用volatile關鍵字的話，當線程2進行修改時，會致使線程1的工做內存中緩存變量stop的緩存行無效（反映到硬件層的話，就是CPU的L1或者L2緩存中對應的緩存行無效）；

第三：因爲線程1的工做內存中緩存變量stop的緩存行無效，因此線程1再次讀取變量stop的值時會去主存讀取。

那麼在線程2修改stop值時（固然這裏包括2個操做，修改線程2工做內存中的值，而後將修改後的值寫入內存），會使得線程1的工做內存中緩存變量stop的緩存行無效，而後線程1讀取時，發現本身的緩存行無效，它會等待緩存行對應的主存地址被更新以後，而後去對應的主存讀取最新的值。

那麼線程1讀取到的就是最新的正確的值。

2.原子性

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的數字。

可能有的朋友就會有疑問，不對啊，上面是對變量inc進行自增操做，因爲volatile保證了可見性，那麼在每一個線程中對inc自增完以後，在其餘線程中都能看到修改後的值啊，因此有10個線程分別進行了1000次操做，那麼最終inc的值應該是1000*10=10000。

這裏面就有一個誤區了，volatile關鍵字能保證可見性沒有錯，可是上面的程序錯在沒能保證原子性。可見性只能保證每次讀取的是最新的值，可是volatile沒辦法保證對變量的操做的原子性。

在前面已經提到過，自增操做是不具有原子性的，它包括讀取變量的原始值、進行加1操做、寫入工做內存。那麼就是說自增操做的三個子操做可能會分割開執行，就有可能致使下面這種狀況出現：

假如某個時刻變量inc的值爲10，

線程1對變量進行自增操做，線程1先讀取了變量inc的原始值，而後線程1被阻塞了；

而後線程2對變量進行自增操做，線程2也去讀取變量inc的原始值，因爲線程1只是對變量inc進行讀取操做，而沒有對變量進行修改操做，因此不會致使線程2的工做內存中緩存變量inc的緩存行無效，也不會致使主存中的值刷新，因此線程2會直接去主存讀取inc的值，發現inc的值時10，而後進行加1操做，並把11寫入工做內存，最後寫入主存。

而後線程1接着進行加1操做，因爲已經讀取了inc的值，注意此時在線程1的工做內存中inc的值仍然爲10，因此線程1對inc進行加1操做後inc的值爲11，而後將11寫入工做內存，最後寫入主存。

那麼兩個線程分別進行了一次自增操做後，inc只增長了1。

根源就在這裏，自增操做不是原子性操做，並且volatile也沒法保證對變量的任何操做都是原子性的。

解決方案：能夠經過synchronized或lock，進行加鎖，來保證操做的原子性。也能夠經過AtomicInteger。

在java 1.5的java.util.concurrent.atomic包下提供了一些原子操做類，即對基本數據類型的 自增（加1操做），自減（減1操做）、以及加法操做（加一個數），減法操做（減一個數）進行了封裝，保證這些操做是原子性操做。atomic是利用CAS來實現原子性操做的（Compare And Swap），CAS其實是利用處理器提供的CMPXCHG指令實現的，而處理器執行CMPXCHG指令是一個原子性操做。

3.volatile保證有序性

在前面提到volatile關鍵字能禁止指令重排序，因此volatile能在必定程度上保證有序性。

volatile關鍵字禁止指令重排序有兩層意思：

1）當程序執行到volatile變量的讀操做或者寫操做時，在其前面的操做的更改確定所有已經進行，且結果已經對後面的操做可見；在其後面的操做確定尚未進行；

2）在進行指令優化時，不能將在對volatile變量的讀操做或者寫操做的語句放在其後面執行，也不能把volatile變量後面的語句放到其前面執行。

//x、y爲非volatile變量

//flag爲volatile變量

x = 2 ; //語句1

y = 0 ; //語句2

flag = true ; //語句3

x = 4 ; //語句4

y = - 1 ; //語句5

因爲flag變量爲volatile變量，那麼在進行指令重排序的過程的時候，不會將語句3放到語句一、語句2前面，也不會講語句3放到語句四、語句5後面。可是要注意語句1和語句2的順序、語句4和語句5的順序是不做任何保證的。

而且volatile關鍵字能保證，執行到語句3時，語句1和語句2一定是執行完畢了的，且語句1和語句2的執行結果對語句三、語句四、語句5是可見的。

//線程1:context = loadContext();   //語句1inited = true;             //語句2 //線程2:while(!inited ){  sleep()}doSomethingwithconfig(context);複製代碼

volatile的實現原理

處理器爲了提升處理速度，不直接和內存進行通信，而是將系統內部的數據讀到內部緩存後在進行操做，但操做完以後不知道何時會寫入內存。

若是對聲明瞭volatile變量進行寫操做時，JVM會向處理器發送一條Lock前綴的指令，將這個變量所在緩存行的數據寫會到系統內存。 這一步確保了若是有其餘線程對聲明瞭volatile變量進行修改，則當即更新主內存中數據。

但這時候其餘處理器的緩存仍是舊的，因此在多處理器環境下，爲了保證各個處理器緩存一致，每一個處理會經過嗅探在總線上傳播的數據來檢查 本身的緩存是否過時，當處理器發現本身緩存行對應的內存地址被修改了，就會將當前處理器的緩存行設置成無效狀態，當處理器要對這個數據進行修改操做時，會強制從新從系統內存把數據讀處處理器緩存裏。 這一步確保了其餘線程得到的聲明瞭volatile變量都是從主內存中獲取最新的。

Lock前綴指令實際上至關於一個內存屏障（也成內存柵欄），它確保指令重排序時不會把其後面的指令排到內存屏障以前的位置，也不會把前面的指令排到內存屏障的後面；即在執行到內存屏障這句指令時，在它前面的操做已經所有完成。

volatile的應用場景

synchronized關鍵字是防止多個線程同時執行一段代碼，那麼就會很影響程序執行效率，而volatile關鍵字在某些狀況下性能要優於synchronized，可是要注意volatile關鍵字是沒法替代synchronized關鍵字的，由於volatile關鍵字沒法保證操做的原子性。一般來講，使用volatile必須具有如下2個條件：

1）對變量的寫操做不依賴於當前值

2）該變量沒有包含在具備其餘變量的不變式中

狀態標誌

也許實現 volatile 變量的規範使用僅僅是使用一個布爾狀態標誌，用於指示發生了一個重要的一次性事件，例如完成初始化或請求停機。

volatile boolean shutdownRequested;

...

public void shutdown() { 
    shutdownRequested = true; 
}

public void doWork() { 
    while (!shutdownRequested) { 
        // do stuff
    }
}
複製代碼

線程1執行doWork()的過程當中，可能有另外的線程2調用了shutdown，因此boolean變量必須是volatile。

而若是使用 synchronized 塊編寫循環要比使用 volatile 狀態標誌編寫麻煩不少。因爲 volatile 簡化了編碼，而且狀態標誌並不依賴於程序內任何其餘狀態，所以此處很是適合使用 volatile。

這種類型的狀態標記的一個公共特性是：一般只有一種狀態轉換；shutdownRequested 標誌從false 轉換爲true，而後程序中止。這種模式能夠擴展到來回轉換的狀態標誌，可是隻有在轉換週期不被察覺的狀況下才能擴展（從false 到true，再轉換到false）。此外，還須要某些原子狀態轉換機制，例如原子變量。

一次性安全發佈

在缺少同步的狀況下，可能會遇到某個對象引用的更新值（由另外一個線程寫入）和該對象狀態的舊值同時存在。

這就是形成著名的雙重檢查鎖定（double-checked-locking）問題的根源，其中對象引用在沒有同步的狀況下進行讀操做，產生的問題是您可能會看到一個更新的引用，可是仍然會經過該引用看到不徹底構造的對象

未完待續