Java記憶體模型

Java虛擬機器在規範中檢視定義一種Java記憶體模型（Java Memory Model，JMM）來遮蔽掉各種硬體和作業系統的訪問差異，以實現讓Java程式在各種平臺下都能達到一致的記憶體訪問效果。

主記憶體與工作記憶體

Java記憶體模型的主要目標是定義程式中各個變數的訪問規則，此處的變數（Variables）包括例項欄位、靜態欄位和構成陣列物件的元素，但不包括區域性變數和方法引數，因為後者是執行緒私有的。
Java記憶體模型規定了所有的變數都儲存在主記憶體（Main Memory）中。每條執行緒都擁有自己的工作記憶體（Working Memory），執行緒的工作記憶體中儲存了被該執行緒使用到的變數的主記憶體副本拷貝，執行緒對變數的所有操作（讀取、賦值等）都必須在工作記憶體中進行，而不能直接讀寫主記憶體中的變數。不同的執行緒之間也無法直接訪問對方工作記憶體中的變數，執行緒間變數值的傳遞均需通過主記憶體來完成，執行緒、主記憶體、工作記憶體三者的互動關係如下圖所示：

記憶體間互動操作

關於一個變數如何如何從主記憶體拷貝到工作記憶體、如何從工作記憶體同步到主記憶體之類的實現細節，Java記憶體模型中定義了以下8種操作來完成，虛擬機器實現時必須保證下面提及的每一種操作都是原子的、不可再分的。

• lock（鎖定）：作用於主記憶體變數，它把一個變數標識為一條執行緒獨佔的狀態。
• unlock（解鎖）：作用於主記憶體變數，它把一個處於鎖定狀態的變數釋放出來，釋放後的變數才可以被其它執行緒鎖定。
• read（讀取）：作用於主記憶體變數，它把一個變數的值從主記憶體傳輸到執行緒的工作記憶體中，以便隨後的load動作使用。
• load（載入）：作用於工作記憶體變數，它把read操作從主記憶體中得到的變數值放入工作記憶體的變數副本中。
• use（使用）：作用於工作記憶體變數，它把工作記憶體中一個變數的值傳遞給執行引擎，每當虛擬機器遇到一個需要使用到變數的值的位元組碼指令時將會執行這個操作。
• assign（賦值）：作用於工作記憶體變數，它把一個從執行引擎接收到的值賦給工作記憶體的變數，每當虛擬機器遇到一個給變數賦值的位元組碼指令時執行這個操作。
• store（儲存）：作用於工作記憶體的變數，它把工作記憶體中一個變數的值傳送到主記憶體中，以便write操作使用。
• write（寫入）：作用於主記憶體變數，它把store操作從工作記憶體中得到的變數的值放入主記憶體的變數中。

如果要把一個變數從主記憶體複製到工作記憶體，那就要順序地執行read和load操作，如果要把變數從工作記憶體同步回主記憶體，就要順序地執行store和write操作。這兩組操作都只需要順序執行而不必連續。除此之外，Java記憶體模型還規定了在執行上述8種基本操作時必須滿足如下規則：

• 不允許你read和load、store和write操作之一單獨出現，即不允許一個變數從主記憶體讀取了但工作記憶體不接受，或者從工作記憶體發起回寫了但主記憶體不接受的情況出現。
• 不允許一個執行緒丟棄它的assign操作，即變數在工作記憶體中改變了之後必須把該變化同步回主記憶體。
• 不允許一個執行緒無原因地（沒有發生過任何assign）把資料從執行緒的工作記憶體同步到主記憶體。
• 一個新的變數只能在主記憶體中誕生，不允許在工作記憶體中直接使用一個未被初始化（load或assign）的變數，換句話說，就是對一個變數實施use、store之前，必須先執行過了assign和load操作。
• 一個變數在同一時刻只允許一條執行緒對其進行lock操作，單lock操作可以被同一條執行緒重複執行多次，多次執行lock之後，只有執行相同次數的unlock操作，變數才會被解鎖。
• 如果對一個變數執行lock操作，那將會清空工作記憶體中此變數的值，在執行引擎使用這個變數前，需要重新執行load或assign操作初始化變數的值。
• 如果一個變數事先沒有被lock操作鎖定，那就不允許對它執行unlock操作，也不允許去unlock一個被其它執行緒鎖定的變數。
• 對一個變數執行unlock操作之前，必須先把此變數同步回主記憶體中（只是sotore、write操作）。

volatile關鍵字

關鍵字volatile是Java虛擬機器提供的最輕量級的同步機制，瞭解volatile變數的語義對後面瞭解多執行緒操作的其它特性很有意義。首先，我們來了解一下這個關鍵字的作用。
當一個變數定義為volatile之後，它將具備兩種屬性，第一種是保證此變數對所有執行緒的可見性，這裡的“可見性”是指當一條執行緒修改了這個變數的值，新值對於其它執行緒來說是可以立即得知的。不過，因為Java裡面的運算並不是原子操作，所以volatile變數的運算在併發條件下並不是絕對安全的。以下為示例程式碼：

package com.overridere.twelve;
/**
 * volatile變數自增運算測試
 */
public class VolatileTest {

    public static volatile int race = 0;

    public static void increase() {
        race++;
    }

    private static final int THREADS_COUNT = 20;

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }

        // 等待所有累加執行緒都結束
        while (Thread.activeCount() > 1)
            Thread.yield();

        System.out.println(race);
    }
}

這段程式碼發起了20個執行緒，每個執行緒都對變數race進行10000次自增操作，如果race是執行緒安全的，最後輸出結果應該是200000，但真實結果都是一個小於200000的值，這是問為什麼呢？

 public static void increase();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #13                 // Field race:I
         3: iconst_1
         4: iadd
         5: putstatic     #13                 // Field race:I
         8: return
      LineNumberTable:
        line 10: 0
        line 11: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature

問題就在“race++”中，用javap命令得到上面的位元組碼命令，發現只有一行程式碼的increase()方法在Class檔案中是由4條位元組碼指令構成的，從這上面分析就很容易分析出執行緒不安全的原因了：當getstatic指令把race的值取到運算元棧頂的時候，volatile關鍵字保證了race的值在此時是正確的，但是在執行iconst_1、iadd這些指令的時候，其它執行緒可能已經把race加大了，而操作棧頂的值就變成了過期的資料。意思是說，在這個例子當中，volatile關鍵字只保證getstatic指令從常量池中將值取出放到運算元棧頂這個動作是執行緒安全的（從主記憶體到工作記憶體），作用範圍就是這個，之後就會失去作用，後面的增加操作就不是執行緒安全的了。

• 運算結果並不依賴變數的當前值，或者能夠保證只有單一的執行緒修改變數的值。
• 變數不需要與其它的變數共同參與不變約束。

第一句話的意思是：不管我以前是什麼樣的，都不影響現在的我。
第二句話的意思是：不管別人是什麼樣的，只要跟我沒關係，就不會影響到我。
如下面的示例程式碼：

volatile boolean isVolatile;
public void shutdown(){
    isVolatile = true;
}
public void doWork(){
    while(!isVolatile){
        //do stuff
    }
}

上面程式碼中的isVolatile變數，無論之前是什麼，都不妨礙當前執行緒賦值，也沒有與其它變數綁起來共同參與不變約束。

使用volatile變數的第二個語義是禁止指令重排序優化，普通的變數僅僅會保證在該方法的執行過程中所有依賴賦值結果的地方都能獲取到正確的結果，而不能保證變數賦值操作的順序與程式程式碼中的執行順序一致。因為在一個執行緒的方法執行過程中無法感知到這點，也就是Java記憶體模型中描述的所謂“執行緒內表現為序列的語義”（Within-Thread As-If-Serial Semantics）。

指令重排序意思就是不按程式規定的順序執行指令，但並不是說指令任意重排。比如說，指令1把地址A中的值加10，指令2把地址A中的值乘以2，指令3把地址B中的值減去3，這時指令1和指令2是有依賴的，它們之間的順序不能重排——（A+10）*2與A*2+10顯然不相等，但是指令3可以重排到指令1、2之前或者中間。

而valotile關鍵字是如何實現禁止指令重排序呢？
有volatile關鍵字修飾的變數，賦值後會多執行一個操作，這個操作會把修改同步到記憶體，意味著所有之前的操作都執行完畢了，這個操作相當於記憶體屏障（Memory Barrier），這樣一來指令重排序的時候就不能把後面的指令重排序到記憶體屏障之前的位置。只有一個CPU訪問記憶體時，不需要記憶體屏障。

原子性、可見性與有序性

原子性（Atomicity）：由Java記憶體模型來直接保證的原子性變數操作包括read、load、assign、use、和write。
可見性（Visibility）：可見性是指當一個執行緒修改了共享變數的值，其它執行緒能夠立即得知這個修改。Java記憶體模型是通過在變數修改後將新值同步回主記憶體，在變數讀取前從主記憶體重新整理變數值這種依賴主記憶體作為傳遞媒介的方式來實現可見性的。volatile變數與普通變數的區別是，volatile的特殊規則保證新值能立即同步到主記憶體，每次使用前立即從主記憶體重新整理。
有序性（Ordering）：如果在本執行緒內觀察，所有的操作都是有序的；如果在一個執行緒中觀察另一個執行緒，所有的操作都是無序的。前半句是指“執行緒內表現為序列的語義”，後半句是指“指令重排序”現象和“工作記憶體和主記憶體同步延遲”現象。

現行發生原則

先行發生是Java記憶體模型中定義的兩項操作之間的偏序關係，如果說操作A先行發生於操作B，意思就是在發生操作B之前，操作A產生的影響能被操作B觀察到。請看下面的例子：

//以下操作線上程A中執行

i = 1;
//以下操作線上程B中執行
j = i;

//以下操作線上程C中執行
i = 2;

假設執行緒A中的操作先行發生於執行緒B的操作，name可以確定線上程B的操作執行之後，變數j的值一定等於i，依據有兩個：以是根據現行發生原則，“i=1”的結果可以被執行緒B觀察到；二是執行緒C還沒執行，執行緒A操作結束之後沒有其它執行緒會修改變數i的值。
再把問題變一下，我們依然保持執行緒A和執行緒B的先行發生關係，而執行緒C出現線上程A和執行緒B之間，但是執行緒C和執行緒B沒有先行發生關係，那麼j的值會是多少呢？答案是不確定，因為執行緒C和執行緒B不確定哪條執行緒先執行到對變數j的修改。