來源: blog.csdn.net/fumitzuki/article/details/81630048 volatile關鍵字是由JVM提供的最輕量級同步機制。與被濫用的synchronized不同，我們並不習慣使用它。想要正確且完全的理解它並不容易。 Part1Java記憶體模型 Java記憶體模型 ...

來源: blog.csdn.net/fumitzuki/article/details/81630048

volatile關鍵字是由JVM提供的最輕量級同步機制。與被濫用的synchronized不同，我們並不習慣使用它。想要正確且完全的理解它並不容易。

Part1Java記憶體模型

Java記憶體模型由Java虛擬機規範定義，用來屏蔽各個平臺的硬體差異。簡單來說:

所有變數儲存在主記憶體。
每條線程擁有自己的工作記憶體，其中保存了主記憶體中線程使用到的變數的副本。
線程不能直接讀寫主記憶體中的變數，所有操作均在工作記憶體中完成。線程，主記憶體，工作記憶體的交互關係如圖。

記憶體間的交互操作有很多，和volatile有關的操作為：

read（讀取）：作用於主記憶體變數，把一個變數值從主記憶體傳輸到線程的工作記憶體中，以便隨後的load動作使用

load（載入）：作用於工作記憶體的變數，它把read操作從主記憶體中得到的變數值放入工作記憶體的變數副本中。

use（使用）：作用於工作記憶體的變數，把工作記憶體中的一個變數值傳遞給執行引擎，每當虛擬機遇到一個需要使用變數的值的位元組碼指令時將會執行這個操作。

assign（賦值）：作用於工作記憶體的變數，它把一個從執行引擎接收到的值賦值給工作記憶體的變數，每當虛擬機遇到一個給變數賦值的位元組碼指令時執行這個操作。

store（存儲）：作用於工作記憶體的變數，把工作記憶體中的一個變數的值傳送到主記憶體中，以便隨後的write的操作。

write（寫入）：作用於主記憶體的變數，它把store操作從工作記憶體中一個變數的值傳送到主記憶體的變數中。

對被volatile修飾的變數進行操作時，需要滿足以下規則：

規則1：線程對變數執行的前一個動作是load時才能執行use，反之只有後一個動作是use時才能執行load。線程對變數的read，load，use動作關聯，必須連續一起出現。-----這保證了線程每次使用變數時都需要從主存拿到最新的值，保證了其他線程修改的變數本線程能看到。
規則2：線程對變數執行的前一個動作是assign時才能執行store，反之只有後一個動作是store時才能執行assign。線程對變數的assign，store，write動作關聯，必須連續一起出現。-----這保證了線程每次修改變數後都會立即同步回主記憶體，保證了本線程修改的變數其他線程能看到。
規則3：有線程T，變數V、變數W。假設動作A是T對V的use或assign動作，P是根據規則2、3與A關聯的read或write動作；動作B是T對W的use或assign動作，Q是根據規則2、3與B關聯的read或write動作。如果A先與B，那麼P先與Q。------這保證了volatile修飾的變數不會被指令重排序優化，代碼的執行順序與程式的順序相同。

Part2使用volatile關鍵字的特性

被volatile修飾的變數保證對所有線程可見。

由上文的規則1、2可知，volatile變數對所有線程是立即可見的，在各個線程中不存在一致性問題。那麼，我們是否能得出結論：volatile變數在併發運算下是線程安全的呢？這確實是一個非常常見的誤解，寫個簡單的例子：

public class VolatileTest extends Thread{
    static volatile int increase = 0;
    static AtomicInteger aInteger=new AtomicInteger();//對照組
    static void increaseFun() {
        increase++;
        aInteger.incrementAndGet();
    }
    public void run(){
        int i=0;
        while (i < 10000) {
            increaseFun();
            i++;
        }
    }
    public static void main(String[] args) {
        VolatileTest vt = new VolatileTest();
        int THREAD_NUM = 10;
        Thread[] threads = new Thread[THREAD_NUM];
        for (int i = 0; i < THREAD_NUM; i++) {
            threads[i] = new Thread(vt, "線程" + i);
            threads[i].start();
        }
        //idea中會返回主線程和守護線程，如果用Eclipse的話改為1
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("volatile的值: "+increase);
        System.out.println("AtomicInteger的值: "+aInteger);
    }
}

這個程式我們跑了10個線程同時對volatile修飾的變數進行10000的自增操作(AtomicInteger實現了原子性，作為對照組)，如果volatile變數是併發安全的話，運行結果應該為100000，可是多次運行後，每次的結果均小於預期值。顯然上文的說法是有問題的。

volatile修飾的變數並不保值原子性，所以在上述的例子中，用volatile來保證線程安全不靠譜。我們用Javap對這段代碼進行反編譯，為什麼不靠譜簡直一目瞭然：

getstatic指令把increase的值拿到了操作棧的頂部，此時由於volatile的規則，該值是正確的。

iconst_1和iadd指令在執行的時候increase的值很有可能已經被其他線程加大，此時棧頂的值過期。

putstatic指令接著把過期的值同步回主存，導致了最終結果較小。

volatile關鍵字只保證可見性，所以在以下情況中，需要使用鎖來保證原子性：

運算結果依賴變數的當前值，並且有不止一個線程在修改變數的值。
變數需要與其他狀態變數共同參與不變約束

那麼volatile的這個特性的使用場景是什麼呢？

模式1：狀態標誌

模式2：獨立觀察（independent observation）

模式3：“volatile bean” 模式

模式4：開銷較低的“讀－寫鎖”策略

具體場景 -- blog.csdn.net/vking_wang/article/details/9982709

禁止指令重排序優化。

由上文的規則3可知，volatile變數的第二個語義是禁止指令重排序。指令重排序是什麼？簡單點說就是 jvm會把代碼中沒有依賴賦值的地方打亂執行順序，由於一些規則限定，我們在單線程內觀察不到打亂的現象（線程內表現為串列的語義），但是在併發程式中，從別的線程看另一個線程，操作是無序的。一個非常經典的指令重排序例子：

public class SingletonTest {
    private volatile static SingletonTest instance = null;
    private SingletonTest() { }
    public static SingletonTest getInstance() {
        if(instance == null) {
            synchronized (SingletonTest.class){
                if(instance == null) {
                    instance = new SingletonTest();  //非原子操作
                }
            }
        }
        return instance;
    }
}

這是單例模式中的“雙重檢查加鎖模式”，我們看到instance用了volatile修飾，由於 instance = new SingletonTest();可分解為：