Java併發程式設計——為什麼要用volatile關鍵字

leapMie發表於2020-07-08
Java程式設計

首發地址 https://blog.leapmie.com/archives/66ba646f/

日常程式設計中出現 volatile 關鍵字的頻率並不高，大家可能對 volatile 關鍵字比較陌生，再深入一點也許是聽聞 volatile 只能保證可見性而不能保證原子性，無法有效保證執行緒安全，於是更加避免使用 volatile ，簡簡單單加上synchronize關鍵字就完事了。本文稍微深入探討 volatile 關鍵字，分析其作用及對應的使用場景。

併發程式設計的幾個概念簡述

首先簡單介紹幾個與併發程式設計相關的概念：

  • 可見性

    可見性是指變數線上程之間是否可見，JVM 中預設情況下執行緒之間不具備可見性。

  • 原子性

    對於 a = 0 操作是屬於原子操作，但 a = a + 1 則不是原子操作，因為這裡涉及到要先讀取原來 a 的值，然後再為 a 加 1 ，當涉及多執行緒同時執行該語句時，會出現值不穩定的情況，所以非原子操作在併發場景下是不安全的。

  • 有序性

    java 記憶體模型中允許編譯器和處理器進行指令重排優化，重排過程中不會影響單個執行緒的指令執行順序，但會影響多執行緒環境中的執行正確性

  • 指令重排

    在多核 CPU 的情況下，為了充分利用時間片，提高指令執行效率，處理器會根據一定規則對指令進行重排序，由於規則的限定，指令重排後理論上最終執行結果不變。

volatile 的主要作用

volatile 的主要作用是實現可見性 和禁止指令重排

  1. 實現可見性

    在 JVM 記憶體模型中記憶體分為主記憶體和工作記憶體，各執行緒有獨自的工作記憶體，對於要操作的資料會從主記憶體拷貝一份到工作記憶體中，預設情況下工作記憶體是相互獨立的，也就是執行緒之間不可見，而 volatile 最重要的作用之一就是使變數實現可見性。

  2. 禁止指令重排

    雖然指令重排理論上不會影響執行結果的正確性，但指令重排只能保證底層的機器語言重排序後結果正確，而對於Java高階語言，所以在沒有干預的情況下並不能確保每條語句在編譯對應的指令重排後與期望的執行效果一致。

對於以下示例，由於 ready 沒有指定 volatile ，當變數 ready 執行緒間不可見時，可能導致執行緒中讀不到 ready 的新值，無法停止迴圈；如果指令重排序，可能線上程執行前變數 ready 已賦值為 true ，導致執行緒內容不列印。

public class NoVisibility {
    private static boolean ready;
    private static int number;
    private static class ReaderThread extends Thread {
        @Override
        public void run() {
            while(!ready) {
                Thread.yield();
            }
            System.out.println("1");
        }
    }
    public static void main(String[] args) {
        new ReaderThread().start();
        ready = true;
    }
}

為什麼volatile不能保證執行緒安全？

想要執行緒安全必須保證原子性，可見性，有序性，而 volatile 只能保證可見性和有序性。

volatile 欄位主要是讓執行緒從主記憶體中獲取值從而保證可見性，但是CPU中還有一層快取記憶體——暫存器，對於非原子性操作，在底層指令運算中還是會出現資料快取導致運算結果不正確的情況，從而無法保證執行緒安全。
簡單來說，volatile 在多 cpu 環境下不能保證其它 cpu 的快取同步重新整理，因此無法保證原子性。

為什麼不直接用synchronized

synchronized 可保證原子性、可見性、有序性，能有效保證執行緒安全，但是有個缺點是效能開銷較大，而 volatile 是輕量級的執行緒安全實現方案，在某些特定場合下也能保證執行緒安全。由於 synchronized 的便捷性，也容易導致 synchronized 的濫用。

雙重檢查鎖

因為 volatile 不能簡易的實現執行緒安全，需要有較深入的瞭解才能正確使用，所以 volatile也顯得更為複雜，使用頻率也較低，而 volatile 的一個典型使用例子是雙重檢查鎖模式。

雙重檢查鎖通常用於單例模式或延遲賦值的場景，其程式碼通常如下

public class Singleton {
    private volatile static Singleton uniqueSingleton; // 1. 為變數新增volatile修飾符

    private Singleton() {
    }

    public Singleton getInstance() {
        if (null == uniqueSingleton) { //2. 第一重檢查
            synchronized (Singleton.class) { // 3. synchronized加鎖
                if (null == uniqueSingleton) { // 4. 第二重檢查
                    uniqueSingleton = new Singleton();
                }
            }
        }
        return uniqueSingleton;
    }
}

以下是對這段程式碼的一些疑問及解答：

Q: 為什麼不在 getInstance 方法直接加 synchronized ？

A: 只有在第一次初始化時才需要加鎖，如果在getInstance方法上加鎖則每次獲取例項時都會對整段程式碼塊加鎖，影響效能

Q: 為什麼需要雙重檢查？

A: 如果多執行緒同時通過了第一次檢查，其中一個執行緒需要通過了第二次檢查才進行例項化物件，其餘執行緒在後續等待獲取到鎖後則判斷到變數非空，跳過賦值操作。

Q: 為什麼 uniqueSingleton 需要新增volatile關鍵字？

A: 對於 uniqueSingleton = new Singleton();語句，實際上可以分解成以下三個步驟：

  1. 分配記憶體空間
  2. 初始化物件
  3. 將物件指向剛分配的記憶體空間

但是有些編譯器為了效能的原因，可能會將第二步和第三步進行重排序，順序就成了：

  1. 分配記憶體空間
  2. 將物件指向剛分配的記憶體空間
  3. 初始化物件

現在考慮重排序後，兩個執行緒發生了以下呼叫：

Time Thread A Thread B
T1 檢查到uniqueSingleton為空
T2 獲取鎖
T3 再次檢查到uniqueSingleton為空
T4 為uniqueSingleton分配記憶體空間
T5 將uniqueSingleton指向記憶體空間
T6 檢查到uniqueSingleton不為空
T7 訪問uniqueSingleton（此時物件還未完成初始化）
T8 初始化uniqueSingleton

在這裡新增volatile關鍵字主要是避免在物件未完整完成物件建立就已經被其他執行緒讀取，造成空指標異常。

總結

  1. volatile 的主要作用是實現可見性和禁止指令重排。
  2. 執行緒安全需要滿足可見性、有序性、原子性。
  3. volatile 可以保證可見性和有序性，但是無法保證原子性，所以是執行緒不安全的。（非原子操作可能會導致資料快取在CPU的cache中，產生資料不一致）
  4. synchronized 關鍵字雖然可以保證可見性、有序性、原子性，而且用法簡單，但是效能開銷大。
  5. 雙重檢查鎖模式是 volatile 的典型使用場景，雙重檢查鎖通常用於實現單例模式或延遲賦值。

參考

Java中Volatile關鍵字詳解

java volatile關鍵字解惑

為什麼雙重檢查鎖模式需要 volatile ？

Java中的雙重檢查鎖（double checked locking）

相關文章