多線程系列(四) -volatile關鍵字使用詳解

在上篇文章中，我們介紹到在多線程環境下，如果編程不當，可能會出現程式運行結果混亂的問題。出現這個原因主要是，JMM 中主記憶體和線程工作記憶體的數據不一致，以及多個線程執行時無序，共同導致的結果。 ...

一、簡介

在上篇文章中，我們介紹到在多線程環境下，如果編程不當，可能會出現程式運行結果混亂的問題。

出現這個原因主要是，JMM 中主記憶體和線程工作記憶體的數據不一致，以及多個線程執行時無序，共同導致的結果。

同時也提到引入synchronized同步鎖，可以保證線程同步，讓多個線程依次排隊執行被synchronized修飾的方法或者方法塊，使程式的運行結果與預期一致。

不可否認，採用synchronized同步鎖確實可以保證線程安全，但是它對服務性能的消耗也很大，synchronized是一個獨占式的同步鎖，比如當多個線程嘗試獲取鎖時，其中一個線程獲取到鎖之後，未獲取到鎖的線程會不斷的嘗試獲取鎖，而不會發生中斷，當衝突嚴重的時候，線程會直接進入阻塞狀態，不能再乾別的活。

為了實現線程之間更加方便的訪問共用變數，Java 編程語言還提供了另一種同步機制：volatile域變數，在某些場景下使用它會更加方便。

一般來說，被volatile修飾的變數，可以保證所有線程看到這個變數都是同一個值，同時它不會引起線程上下文的切換和調度，相比synchronized，volatile更加的輕量化。

比較官方的解釋，volatile修飾變數有以下幾個作用：

1.保證變數的可見性，不保證原子性
當用volatile修飾一個變數時，JMM 會把當前線程本地記憶體中的變數強制刷新到主記憶體中去，這個寫操作也會導致其他線程中被volatile修飾的變數緩存無效，然後從主記憶體中獲取最新的值
2.禁止指令重排
正常情況下，編譯器和處理器為了優化程式執行性能會對指令序列進行重排序，當然是在不影響程式結果的前提下。volatile能夠在一定程度上禁止 JVM 進行指令重排。

從概念上感覺比較難理解，下麵我們結合幾個例子，一起來看看它的具體應用。

二、volatile 使用詳解

我們先看一個例子。

public class DataEntity {

    private boolean isRunning = true;

    public void addCount(){
        System.out.println("線程運行開始....");
        while (isRunning){ }
        System.out.println("線程運行結束....");
    }

    public boolean isRunning() {
        return isRunning;
    }

    public void setRunning(boolean running) {
        isRunning = running;
    }
}

public class MyThread extends Thread {

    private DataEntity entity;

    public MyThread(DataEntity entity) {
        this.entity = entity;
    }

    @Override
    public void run() {
        entity.addCount();
    }
}

public class MyThreadTest {

    public static void main(String[] args) throws InterruptedException {
        // 初始化數據實體
        DataEntity entity = new DataEntity();

        MyThread threadA = new MyThread(entity);
        threadA.start();

        // 主線程阻塞1秒
        Thread.sleep(1000);

        // 將運行狀態設置為false
        entity.setRunning(false);
    }
}

運行結果如下：

從實際運行結果來看，程式進入死迴圈狀態，雖然最後一行手動設置了entity.setRunning(false)，但是沒有起到任何的作用。

原因其實也很簡單，雖然主線程main將isRunning變數設置為false，但是線程threadA 裡面的isRunning變數還是true，兩個線程看到的數據不一致。

假如在isRunning變數上，加一個volatile關鍵字，我們再來看看運行效果。

/**
 * 在 isRunning 變數上加一個 volatile 關鍵字
 */
private volatile boolean isRunning = true;

運行結果如下：

程式運行後自動結束。

說明當主線程main將isRunning變數設置為false時，線程threadA 裡面的isRunning值也隨著發生變化。

說明被volatile修飾的變數，在多線程環境下，可以保證所有線程看到這個變數都是同一個值。

三、volatile 不適用的場景

對於某些場景下，volatile可能並不適用，我們還是先看一個例子。

public class DataEntity {

    private volatile int count = 0;

    public void addCount(){
        for (int i = 0; i < 100000; i++) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

public class MyThreadTest {

    public static void main(String[] args) throws InterruptedException {
        // 初始化數據實體
        DataEntity entity = new DataEntity();

        // 初始化5個線程計數器
        CountDownLatch latch = new CountDownLatch(5);

        // 採用多線程進行操作
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    entity.addCount();
                    //線程運行完畢減1
                    latch.countDown();
                }
            }).start();
        }

        // 等待以上線程執行完畢，再獲取結果
        latch.await();
        System.out.println("result: " + entity.getCount());
    }
}

運行結果如下：

第一次運行：result: 340464
第二次運行：result: 318342
第三次運行：result: 305957

理論上使用 5 個線程分別執行了100000自增，我們預期的結果應該是5*100000=500000，從實際的運行結果可以看出，與預期不一致。

這是因為volatile的作用其實是有限的，它只能保證多個線程之間看到的共用變數值是最新的，但是無法保證多個線程操作共用變數時依次有序，無法保證原子性操作。

上面的例子中count++不是一個原子性操作，在處理器看來，其實一共做了三個步驟的操作：讀取數據、對數據加 1、回寫數據，在多線程隨機執行情況下，輸出結果不能達到預期值。

如果想要實現與預期一致的結果，有以下三種方案可選。

方案一：採用synchronized同步鎖

public class DataEntityC2 {

    private int count = 0;

    /**
     * 採用 synchronized 同步鎖，可以實現多個線程執行方法時串列
     */
    public synchronized void addCount(){
        for (int i = 0; i < 100000; i++) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

方案二：採用Lock鎖

public class DataEntityC2 {

    private int count = 0;

    private Lock lock = new ReentrantLock();

    /**
     * 採用 Lock 鎖，可以實現多個線程執行方法時串列
     */
    public void addCount(){
        for (int i = 0; i < 100000; i++) {
            lock.lock();
            try {
                count++;
            } finally {
                lock.unlock();
            }
        }
    }

    public int getCount() {
        return count;
    }
}

方案三：採用JUC包中的原子操作類

public class DataEntity {

    private AtomicInteger inc = new AtomicInteger();

    /**
     * 採用原子操作類，原子操作類是通過CAS迴圈的方式來保證操作原子性
     */
    public void addCount(){
        for (int i = 0; i < 100000; i++) {
            inc.getAndIncrement();
        }
    }

    public int getCount() {
        return inc.get();
    }
}

以上三種方案，都可以實現程式的運行結果與預期一致！

四、volatile 的原理

通過以上的例子介紹，相信大家對volatile關鍵字的作用有了一些認識。

volatile修飾的變數，可以保證變數在記憶體中的可見性，但是無法保證原子性操作。

關於原子性、可見性和有序性的定義，這三個特性主要從多線程編程安全形度總結出來的一些基本要素，也是併發編程的三大核心基礎，在上篇文章中有所提到過，這裡不再重覆講了。

在 JVM 底層，volatile是通過採用“記憶體屏障”來實現記憶體可見性和禁止指令重排。觀察不加入volatile和加入volatile關鍵字所生成的彙編代碼發現，加入volatile關鍵字的代碼會多出一個lock首碼指令，lock首碼指令實際上相當於一個記憶體屏障，可以提供以下 3 個功能。

1.它確保指令重排序時，不會把後面的指令排到記憶體屏障之前的位置，也不會把前面的指令排到記憶體屏障的後面，禁止處理器對影響程式執行結果的指令進行重排
2.它會強制將緩存的修改操作立刻寫入主存，保證記憶體變數可見
3.如果是寫操作，它會導致其它 CPU 中對應的行緩存無效，目的是讓其他線程中被volatile修飾的變數緩存無效，然後從主記憶體中獲取最新的值

五、單例模式中的雙重檢鎖為什麼要加 volatile？

在上篇文章中，我們提到過單例設計模式中的雙重校驗鎖實現。

public class Singleton {  

    private volatile static Singleton singleton;  
    
    private Singleton (){}  
    
    public static Singleton getSingleton() {  
        if (singleton == null) {  //第一行
            synchronized (Singleton.class) {  //第二行
                if (singleton == null) {  //第三行
                    singleton = new Singleton();  //第四行
                }  
            }  
        }  
        return singleton;  //第五行
    }  
}

synchronized可以保證原子性、可見性和有序性，為什麼變數singleton還需要加volatile關鍵字呢？

之所以需要加volatile關鍵字的原因是：問題出在第一行代碼不在同步代碼塊之類，可能出現這個對象地址不為空，但是內容為空。

以初始化一個Singleton singleton = new Singleton();為例，JVM 會分三個步驟完成：

a. memory = allocate() //分配記憶體
b. ctorInstanc(memory) //初始化對象
c. instance = memory   //設置instance指向剛分配的地址

上面的代碼在編譯運行時可能會出現重排序，因為b和c無邏輯關聯，執行的順序是a -> b -> c或者a -> c -> b，在多線程的環境下可能會出現問題。

分析過程如下：

1.線程 A 執行到第四行代碼時，線程 B 進來執行第一行代碼
2.假設線程 A 在執行過程中發生了指令重排序，先執行了a和c，沒有執行b
3.由於線程 A 執行了c導致instance指向了一段地址，此時線程 B 檢查singleton發現不為null，會直接跳轉到第五行代碼，返回一個未初始化的對象，導致程式會出現報錯
4.因此需要在singleton變數上加一個volatile關鍵字，當線程 A 執行完畢b操作之後，會變數強制刷新到主記憶體中，此時線程 B 也可以拿到最新的對象