學妹教你並發編程的三大特性：原子性、可見性、有序性

• 2020 年 5 月 18 日
• 筆記

在並發編程中有三個非常重要的特性：原子性、有序性,、可見性，學妹發現你對它們不是很了解，她很著急，因為理解這三個特性對於能夠正確地開發高並發程式有很大的幫助，接下來的面試中也極有可能被問到，小學妹就忍不住開始跟你逐一介紹起來。

Java記憶體模型

在講三大特性之前先簡單介紹一下Java記憶體模型（Java Memory Model，簡稱JMM），了解了Java記憶體模型以後，可以更好地理解三大特性。

Java記憶體模型是一種抽象的概念，並不是真實存在的，它描述的是一組規範或者規定。JVM運行程式的實體是執行緒，每一個執行緒都有自己私有的工作記憶體。Java記憶體模型中規定了所有變數都存儲在主記憶體中，主記憶體是一塊共享記憶體區域，所有執行緒都可以訪問。但是執行緒對變數的讀取賦值等操作必須在自己的工作記憶體中進行，在操作之前先把變數從主記憶體中複製到自己的工作記憶體中，然後對變數進行操作，操作完成後再把變數寫回主記憶體。執行緒不能直接操作主記憶體中的變數，執行緒的工作記憶體中存放的是主記憶體中變數的副本。

歡迎關注微信公眾號：萬貓學社，每周一分享Java技術乾貨。

原子性（Atomicity）

什麼是原子性

原子性是指：在一次或者多次操作時，要麼所有操作都被執行，要麼所有操作都不執行。

一般說到原子性都會以銀行轉賬作為例子，比如張三向李四轉賬100塊錢，這包含了兩個原子操作：在張三的賬戶上減少100塊錢；在李四的賬戶上增加100塊錢。這兩個操作必須保證原子性的要求，要麼都執行成功，要麼都執行失敗。不能出現張三的賬戶減少100塊錢而李四的賬戶沒增加100塊錢，也不能出現張三的賬戶沒減少100塊錢而李四的賬戶卻增加100塊錢。

原子性示例

示例一

i = 1;

根據上面介紹的Java記憶體模型，執行緒先把i=1寫入工作記憶體中，然後再把它寫入主記憶體，就此賦值語句可以說是具有原子性。

示例二

i = j;

這個賦值操作實際上包含兩個步驟：執行緒從主記憶體中讀取j的值，然後把它存入當前執行緒的工作記憶體中；執行緒把工作記憶體中的i改為j的值，然後把i的值寫入主記憶體中。雖然這兩個步驟都是原子性的操作，但是合在一起就不是原子性的操作。

示例三

i++;

這個自增操作實際上包含三個步驟：執行緒從主記憶體中讀取i的值，然後把它存入當前執行緒的工作記憶體中；執行緒把工作記憶體中的i執行加1操作；執行緒再把i的值寫入主記憶體中。和上一個示例一樣，雖然這三個步驟都是原子性的操作，但是合在一起就不是原子性的操作。

從上面三個示例中，我們可以發現：簡單的讀取和賦值操作是原子性的，但把一個變數賦值給另一個變數就不是原子性的了；多個原子性的操作放在一起也不是原子性的。

如何保證原子性

在Java記憶體模型中，只保證了基本讀取和賦值的原子性操作。如果想保證多個操作的原子性，需要使用synchronized關鍵字或者Lock相關的工具類。如果想要使int、long等類型的自增操作具有原子性，可以用java.util.concurrent.atomic包下的工具類，如：AtomicInteger、AtomicLong等。另外需要注意的是，volatile關鍵字不具有保證原子性的語義。

歡迎關注微信公眾號：萬貓學社，每周一分享Java技術乾貨。

可見性（Visibility）

什麼是可見性

可見性是指：當一個執行緒對共享變數進行修改後，另外一個執行緒可以立即看到該變數修改後的最新值。

可見性示例

package onemore.study;

import java.text.SimpleDateFormat;
import java.util.Date;

public class VisibilityTest {
    public static int count = 0;

    public static void main(String[] args) {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");

        //讀取count值的執行緒
        new Thread(() -> {
            System.out.println("開始讀取count...");
            int i = count;//存放count的更新前的值
            while (count < 3) {
                if (count != i) {//當count的值發生改變時，列印count被更新
                    System.out.println(sdf.format(new Date()) + " count被更新為" + count);
                    i = count;//存放count的更新前的值
                }
            }
        }).start();

        //更新count值的執行緒
        new Thread(() -> {
            for (int i = 1; i <= 3; i++) {
                //每隔1秒為count賦值一次新的值
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(sdf.format(new Date()) + " 賦值count為" + i);
                count = i;

            }
        }).start();
    }
}

在運行程式碼之前，先想一下運行的輸出是什麼樣子的？在更新count值的執行緒中，每一次更新count以後，在讀取count值的執行緒中都會有一次輸出嘛？讓我們來看一下運行輸出是什麼：

開始讀取count...
17:21:54.796 賦值count為1
17:21:55.798 賦值count為2
17:21:56.799 賦值count為3

從運行的輸出看出，讀取count值的執行緒一直沒有讀取到count的最新值，這是為什麼呢？因為在讀取count值的執行緒中，第一次讀取count值時，從主記憶體中讀取count的值後寫入到自己的工作記憶體中，再從工作記憶體中讀取，之後的讀取的count值都是從自己的工作記憶體中讀取，並沒有發現更新count值的執行緒對count值的修改。

如何保證可見性

在Java中可以用以下3種方式保證可見性。

使用volatile關鍵字

當一個變數被volatile關鍵字修飾時，其他執行緒對該變數進行了修改後，會導致當前執行緒在工作記憶體中的變數副本失效，必須從主記憶體中再次獲取，當前執行緒修改工作記憶體中的變數後，同時也會立刻將其修改刷新到主記憶體中。

使用synchronized關鍵字

synchronized關鍵字能夠保證同一時刻只有一個執行緒獲得鎖，然後執行同步方法或者程式碼塊，並且確保在鎖釋放之前，會把變數的修改刷新到主記憶體中。

使用Lock相關的工具類

Lock相關的工具類的lock方法能夠保證同一時刻只有一個執行緒獲得鎖，然後執行同步程式碼塊，並且確保執行Lock相關的工具類的unlock方法在之前，會把變數的修改刷新到主記憶體中。

歡迎關注微信公眾號：萬貓學社，每周一分享Java技術乾貨。

有序性（Ordering）

什麼是有序性

有序性指的是：程式執行的順序按照程式碼的先後順序執行。

在Java中，為了提高程式的運行效率，可能在編譯期和運行期會對程式碼指令進行一定的優化，不會百分之百的保證程式碼的執行順序嚴格按照編寫程式碼中的順序執行，但也不是隨意進行重排序，它會保證程式的最終運算結果是編碼時所期望的。這種情況被稱之為指令重排（Instruction Reordering）。

有序性示例

package onemore.study;

public class Singleton {
    private Singleton (){}

    private static boolean isInit = false;
    private static Singleton instance;

    public static Singleton getInstance() {
        if (!isInit) {//判斷是否初始化過
            instance = new Singleton();//初始化
            isInit = true;//初始化標識賦值為true
        }
        return instance;
    }
}

這是一個有問題的單例模式示例，假如在編譯期或運行期時指令重排，把isInit = true;重新排序到instance = new Singleton();的前面。在單執行緒運行時，程式重排後的執行結果和程式碼順序執行的結果是完全一樣的，但是多個執行緒一起執行時就極有可能出現問題。比如，一個執行緒先判斷isInit為false進行初始化，本應在初始化後再把isInit賦值為true，但是因為指令重排沒後初始化就把isInit賦值為true，恰好此時另外一個執行緒在判斷是否初始化過，isInit為true就執行返回了instance，這是一個沒有初始化的instance，肯定造成不可預知的錯誤。

如何保證有序性

這裡就要提到Java記憶體模型的一個叫做先行發生（Happens-Before）的原則了。如果兩個操作的執行順序無法從Happens-Before原則推到出來，那麼可以對它們進行隨意的重排序處理了。Happens-Before原則有哪些呢？

• 程式次序原則：一段程式碼在單執行緒中執行的結果是有序的。
• 鎖定原則：一個鎖處於被鎖定狀態，那麼必須先執行unlock操作後面才能進行lock操作。
• volatile變數原則：同時對volatile變數進行讀寫操作，寫操作一定先於讀操作。
• 執行緒啟動原則：Thread對象的start方法先於此執行緒的每一個動作。
• 執行緒終結原則：執行緒中的所有操作都先於對此執行緒的終止檢測。
• 執行緒中斷原則：對執行緒interrupt方法的調用先於被中斷執行緒的程式碼檢測到中斷事件的發生。
• 對象終結原則：一個對象的初始化完成先於它的finalize方法的開始。
• 傳遞原則：操作A先於操作B，操作B先於操作C，那麼操作A一定先於操作C。

除了Happens-Before原則提供的天然有序性，我們還可以用以下幾種方式保證有序性：

• 使用volatile關鍵字保證有序性。
• 使用synchronized關鍵字保證有序性。
• 使用Lock相關的工具類保證有序性。

總結

• 原子性：在一次或者多次操作時，要麼所有操作都被執行，要麼所有操作都不執行。
• 可見性：當一個執行緒對共享變數進行修改後，另外一個執行緒可以立即看到該變數修改後的最新值。
• 有序性：程式執行的順序按照程式碼的先後順序執行。

synchronized關鍵字和Lock相關的工具類可以保證原子性、可見性和有序性，volatile關鍵字可以保證可見性和有序性，不能保證原子性。

微信公眾號：萬貓學社

微信掃描二維碼

獲得更多Java技術乾貨