Java併發程式設計：JMM (Java記憶體模型) 以及與volatile關鍵字詳解

xue無止境發表於2018-12-29
Java程式設計記憶體模型

目錄

計算機系統的一致性

在現代計算機作業系統中，多工處理幾乎是一項必備的功能，因為嵌入了多核處理器，計算機系統真正做到了同一時間執行若干個任務，是名副其實的多核系統。在多核系統中，為了提升CPU與記憶體的互動效率，一般都設定了一層 “快取記憶體區” 作為記憶體與處理器之間的緩衝，使得CPU在運算的過程中直接從快取記憶體區讀取資料，一定程度上解決了效能的問題。但是，這樣也帶來了一個新問題，就是“快取一致性”的問題。比如，多核的情況下，每個處理器都有自己的快取區，資料如何保持一致性。針對這個問題，現代的計算機系統引入多處理器的資料一致性的協議，包括MOSI、Synapse、Firely、DragonProtocol等。

當處理器通過快取記憶體區與主記憶體發生互動時，對資料的讀寫必須遵循協議規定的標準，用一張關係圖表示的話大概如下：
Java併發程式設計：JMM (Java記憶體模型) 以及與volatile關鍵字詳解

而Java的記憶體模型 (JMM) 可以說與硬體的一致性模型很相似，採用的是共享記憶體的執行緒通訊機制。

Java記憶體模型

Java記憶體模型規定了所有的變數都儲存在主記憶體中，每個執行緒擁有自己的工作記憶體，工作記憶體中儲存了被該執行緒使用的變數的主記憶體副本拷貝，執行緒只能操作自己工作記憶體的變數副本，操作完變數後會更新到主記憶體，通過主記憶體來完成與其他執行緒間變數值的傳遞。此模型的互動關係如下圖所示：
Java併發程式設計：JMM (Java記憶體模型) 以及與volatile關鍵字詳解

然而，Java的記憶體模型只是反映了虛擬機器內部的執行緒處理機制，並不保證程式本身的併發安全性。

舉一個例子，在程式中對一個共享變數做自增操作：

i++；

假設初始化的時候i=0，當跑到此程式時，執行緒首先從主記憶體讀取i的值，然後複製到自己的工作記憶體，進行i++操作，最後將操作後的結果從工作記憶體複製到主記憶體中。如果是兩個執行緒執行i++的程式，預期的結果是2。但真的是這樣嗎？答案是否定的。

假設執行緒1讀取主記憶體的i=0，複製到自己的工作記憶體，在進行i++的操作後還沒來得及更新到主記憶體，這時執行緒2也讀取i=0，做了同樣的操作，那麼最終得到的結果為1，而不是2。

這是典型的關於多執行緒併發安全例子，也是Java併發程式設計中最值得探討的話題之一，一般來說，處理這種問題有兩種手段：

  • 加鎖，比如同步程式碼塊的方式。保證同一時間只能有一個執行緒能執行i++這條程式。
  • 利用執行緒間的通訊，比如使用物件的wait和notify方法來。

因為本文主要是探究 JMM 和 volatile 關鍵字的知識，具體怎麼實現併發處理就不做深入探討了，改天看看抽個時間再寫篇博文專門講解好了。

記憶體模型的3個重要特徵

初步瞭解完什麼是JMM後，我們來進一步瞭解它的重要特徵。值得說明的是，在Java多執行緒開發中，遵循著三個基本特性，分別是原子性、可見性和有序性，而Java的記憶體模型正是圍繞著在併發過程中如何處理這三個特徵建立的。

原子性

原子性是指操作是原子性的，不可中斷的。舉個例子：

String s="abc";

這個操作是直接賦值，是原子性操作。而類似下面這段程式碼就不是原子性了：

i++;

當執行i++時，需要先獲取i的值，然後再執行i+1，相當於包含了兩個操作，所以不是原子性。

可見性

可見性是指共享資料的時候，一個執行緒修改了資料，其他執行緒知道資料被修改，會重新讀取最新的主存的資料。就像前面說的兩個執行緒處理i++的問題，執行緒1改完後沒有更新到主記憶體，所以執行緒2是不知道的。

有序性

是指程式碼執行的有序性，對於一個執行緒執行的程式碼，我們可以認為程式碼是依次執行的，但併發中可能就會出現亂序，因為程式碼有可能發生指令重排序（Instruction Reorder），重排後的指令與原指令的順序未必一致。

指令重排序

編譯器能夠自由的以優化的名義去改變指令順序。在特定的環境下，處理器可能會次序顛倒的執行指令。是為指令的重排序，尤其是併發的情況下。

java提供了volatile和synchronized來保證執行緒之間操作的有序性。volatile含有禁止指令重排序的語義(即它的第二個語義)，synchronized規定一個變數在同一時刻只允許一條執行緒對其lock操作，也就是說同一個鎖的兩個同步塊只能序列進入。禁止了指令的重排序。

volatile關鍵字

說到了volatile，我們就有必要了解一下這個關鍵字是做什麼的。

準確來說，volatile是java提供的輕量的同步機制。它有兩個特性：

  1. 保證修飾的變數對所有執行緒的可見性。
  2. 禁止指令的重排序優化。

保證可見性和防止指令重排

簡單寫段程式碼說明一下：

public class VolatileDemo {
    
    private static boolean isReady;
    private static int number;
    
    private static class ReaderThread extends Thread{
        @Override
        public void run() {
            while (!isReady);
            System.out.println("number = "+number);
        }
    }

    public static void main(String[] args) {
        new ReaderThread().start();
        try {
            Thread.sleep(1000);
            number = 42;
            isReady = true;
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的程式碼中，ReaderThread只有在isReady 為 true 時才會列印出 number 的值，然而，真實的情況有可能是列印不出來(可能性比較小，但還是有)，因為執行緒ReaderThread執行緒無法看到主執行緒中對isReady的修改，導致while迴圈永遠無法退出，同時，因為有可能發生指令重排，導致下面的程式碼不能按順序執行：

number = 42;
isReady = true;

也就是能列印的話，number值可能是0，不是42。如果在變數加上volatile關鍵字，告訴Java虛擬機器這兩個變數可能會被不同的執行緒修改，那麼就可以防止上述兩種不正常的情況的發生。

不能保證原子性

volatile能保證可見性和有序性，但無法保證原子性，比如下面的例子：

public class VolatileDemo {

    public static volatile int i = 0;

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

    public static void main(String[] args) throws InterruptedException {
        VolatileDemo test = new VolatileDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++)
                    test.increase();
            }).start();
        }      
        Thread.sleep(1000);
        System.out.println(test.i);
    }
}

正常情況下，我們期望上面的main函式執行完後輸出的結果是10000，但你會發現，結果總是會小於10000，因為increase()方法中的i++操作不是原子性的，分成了讀和寫兩個操作。假設當執行緒1讀取了 i 的值，還沒有修改，執行緒2這時也進行了讀取。然後，執行緒1修改完了，通知執行緒2重新讀取 i 的值，可這時它不需要讀取 i，它仍執行寫操作，然後賦值給主執行緒，這時資料就會出現問題。

所以，一般針對共享變數的讀寫操作，還是需要用鎖來保證結果，例如加上 synchronized關鍵字。

參考：

《Java高併發程式設計》

《深入理解Java虛擬機器》

相關文章