volatile關鍵字在并發中有哪些作用？-有解無憂

作者：小牛呼嚕嚕 | https://xiaoniuhululu.com
計算機內功、JAVA原始碼、職業成長、專案實戰、面試相關資料等更多精彩文章在公眾號「小牛呼嚕嚕」

前言

讀過筆者之前的一篇文章Java記憶體模型(JMM)詳解, 我們知道了由于計算機為了充分利用CPU的高性能，以及各個硬體存取速度巨大的差異帶來的一系列問題

為了充分壓榨CPU的性能，CPU 會對指令亂序執行或者語言的編譯器會指令重排，讓CPU一直作業不停歇，但同時會導致有序性問題，
為了平衡CPU的暫存器和記憶體的速度差異，計算機的CPU 增加了高速快取，但同時導致了可見性問題
為了平衡CPU 與 I/O 設備的速度差異，作業系統增加了行程、執行緒概念，以分時復用 CPU，但同時導致了原子性問題，

Java 是最早嘗試提供記憶體模型的編程語言，由于Java 語言是跨平臺的，另外各個作業系統總存在一些差異，Java在物理機器的基礎上抽象出一個記憶體模型(JMM)，來簡化和管理并發程式，我們都知道Java并發的三大特性：原子性，可見性，有序性

原子性指的是一個不可以被分割的操作，即這個操作在執行程序中不能被中斷，要么全部不執行，要么全部執行，且一旦開始執行，不會被其他執行緒打斷，
可見性指的是一個執行緒修改了共享變數后，其他執行緒能立即感知這個變數被修改，
有序性指程式按照代碼的先后順序執行，在Java記憶體模型中，為了提升效率是允許編譯器和處理器對指令進行重排序，當然重排序不會影響單執行緒的運行結果，但是對多執行緒會有影響

那么本文我們就聊聊關鍵字volatile ，可能是 Java 中最微妙和最難用的關鍵字, 看看其在Java記憶體模型中是如何保證并發操作的原子性、可見性、有序性的？

讀本文前，可參考JMMhttps://mp.weixin.qq.com/s/iyXN4WyGAV_J4d8zeiG7yA里的每張圖，先理解JMM記憶體模型

什么是volatile關鍵字

volatile是Java中用于修飾變數的關鍵字，其可以保證該變數的可見性以及順序性，但是無法保證原子性，更準確地說是volatile關鍵字只能保證單操作的原子性，比如 x=1，但是無法保證復合操作的原子性，比如x++

其為Java提供了一種輕量級的同步機制：保證被volatile修飾的共享變數對所有執行緒總是可見的，也就是當一個執行緒修改了一個被volatile修飾共享變數的值，新值總是可以被其他執行緒立即得知，相比于synchronized關鍵字（synchronized通常稱為重量級鎖），volatile更輕量級，開銷低，因為它不會引起執行緒背景關系的切換和調度，

保證可見性

可見性：是指當多個執行緒訪問同一個變數時，一個執行緒修改了這個變數的值，其他執行緒能夠立即看到修改的值，我們一起來看一個例子：

public class VisibilityTest {
    private boolean flag = true;

    public void change() {
        flag = false;
        System.out.println(Thread.currentThread().getName() + "，已修改flag=false");
    }

    public void load() {
        System.out.println(Thread.currentThread().getName() + "，開始執行.....");
        int i = 0;
        while (flag) {
            i++;
        }
        System.out.println(Thread.currentThread().getName() + ",結束回圈");
    }

    public static void main(String[] args) throws InterruptedException {
        VisibilityTest test = new VisibilityTest();

        // 執行緒threadA模擬資料加載場景
        Thread threadA = new Thread(() -> test.load(), "threadA");
        threadA.start();

        // 讓threadA執行一會兒
        Thread.sleep(1000);
        // 執行緒threadB 修改 共享變數flag
        Thread threadB = new Thread(() -> test.change(), "threadB");
        threadB.start();

    }
}

其中：threadA 負責回圈，threadB負責修改共享變數flag，如果flag=false時，threadA 會結束回圈，但是上面的例子會死回圈！原因是threadA無法立即讀取到共享變數flag修改后的值，
我們只需 private volatile boolean flag = true;，加上volatile關鍵字threadA就可以立即退出回圈了，

其中Java中的volatile關鍵字提供了一個功能：那就是被volatile修飾的變數P被修改后，JMM會把該執行緒本地記憶體中的這個變數P，立即強制重繪到主記憶體中去，導致其他執行緒中的volatile變數P快取無效，也就是說其他執行緒使用volatile變數P在時，都是從主記憶體重繪的最新資料，而普通變數的值在執行緒間傳遞的時候一般是通過主記憶體以共享記憶體的方式實作的；

因此，可以使用volatile來保證多執行緒操作時變數的可見性，除了volatile，Java中的synchronized和final兩個關鍵字以及各種 Lock也可以實作可見性，加鎖的話，當一個執行緒進入 synchronized代碼塊后，執行緒獲取到鎖，會清空本地記憶體，然后從主記憶體中拷貝共享變數的最新值到本地記憶體作為副本，執行代碼，又將修改后的副本值重繪到主記憶體中，最后執行緒釋放鎖，

保證有序性

有序性，顧名思義即程式執行的順序按照代碼的先后順序執行，但現代的計算機中CPU中為了能夠讓指令的執行盡可能地同時運行起來，提示計算機性能，采用了指令流水線，一個 CPU 指令的執行程序可以分成 4 個階段：取指、譯碼、執行、寫回，這 4 個階段分別由 4 個獨立物理執行單元來完成，

理想的情況是：指令之間無依賴，可以使流水線的并行度最大化但是如果兩條指令的前后存在依賴關系，比如資料依賴，控制依賴等，此時后一條陳述句就必需等到前一條指令完成后，才能開始，所以CPU為了提高流水線的運行效率，對無依賴的前后指令做適當的亂序和調度，即現代的計算機中CPU是亂序執行指令的

另一方面，只要不會改變程式的運行結果，Java編譯器是可以通過指令重排來優化性能，然而，重排可能會影響本地處理器快取與主記憶體互動的方式，可能導致在多執行緒的情況下發生"細微"的BUG，

指令重排一般可以分為如下三種型別：

編譯器優化重排序，編譯器在不改變單執行緒程式語意的前提下，可以重新安排陳述句的執行順序，
指令級并行重排序，現代處理器采用了指令級并行技術來將多條指令重疊執行，如果不存在資料依賴性，處理器可以改變陳述句對應機器指令的執行順序，
記憶體系統重排序，由于處理器使用快取和讀 / 寫緩沖區，這使得加載和存盤操作看上去可能是在亂序執行，這并不是顯式的將指令進行重排序，只是因為快取的原因，讓指令的執行看起來像亂序，

從 Java 源代碼到最終執行的指令序列，一般會經歷下面三種重排序：

變數初始化賦值

我們一起來看一個例子，讓大家體悟volatile關鍵字的禁止指令重排的作用：

int i = 0;
int j = 0;
int k = 0;
i = 10; 
j = 1;

對于上面的代碼我們正常的執行流程是：

初始化i

初始化j

初始化k

i賦值

j賦值

但由于指令重排序問題，代碼的執行順序未必就是撰寫代碼時候的順序，陳述句可能的執行順序如下：

初始化i

i賦值

初始化j

j賦值

初始化k

指令重排對于非原子性的操作，在不影響最終結果的情況下，其拆分成的原子操作可能會被重新排列執行順序,提升性能，指令重排不會影響單執行緒的執行結果，但是會影響多執行緒并發執行的結果正確性，

但當我們用volatile修飾變數k時：

int i = 0;
int j = 0;
volatile int k = 0;
i = 10; 
j = 1;

這樣會保證上面代碼執行順序：變數i和j的初始化，在volatile int k = 0之前，變數i和j的賦值操作在volatile int k = 0后面

懶漢式單例 -- 雙重校驗鎖 volatile版

我們可以使用volatile關鍵字去阻止重排 volatile變數周圍的讀寫指令，這種操作通常稱為 memory barrier （記憶體屏障），詳情可見：https://mp.weixin.qq.com/s/TyiCfVMeeDwa-2hd9N9XJQ 中 懶漢式單例 -- 雙重校驗鎖 volatile版

隱藏特性

volatile關鍵字除了禁止指令重排的作用，還有一個特性：
當執行緒向一個volatile 變數寫入時，在執行緒寫入之前的其他所有變數（包括非volatile變數）也會重繪到主記憶體，當執行緒讀取一個 volatile變數時，它也會讀取其他所有變數（包括非volatile變數）與volatile變數一起重繪到主記憶體，
盡管這是一個重要的特性，但是我們不應該過于依賴這個特性，來"自動"使周圍的變數變得volatile，若是我們想讓一個變數是volatile的，我們撰寫程式的時候需要非常明確地用volatile關鍵字來修飾，

無法保證原子性

volatile關鍵字無法保證原子性，更準確地說是volatile關鍵字只能保證單操作的原子性，比如 x=1，但是無法保證復合操作的原子性，比如x++

所謂原子性：即一個或者多個操作作為一個整體，要么全部執行，要么都不執行，并且操作在執行程序中不會被執行緒調度機制打斷；而且這種操作一旦開始，就一直運行到結束，中間不會有任何背景關系切換（context switch）

int  = 0;   //陳述句1，單操作,原子性的操作

i++;         //陳述句2，復合操作，非原子性的操作

其中：陳述句2i++ 其實在Java中執行程序，可以分為3步：

i 被從區域變數表（記憶體）取出，
壓入操作堆疊（暫存器），操作堆疊中自增
使用堆疊頂值更新區域變數表（暫存器更新寫入記憶體）

執行上述3個步驟的時候是可以進行執行緒切換的，或者說是可以被另其他執行緒的這3 步打斷的，因此陳述句2不是一個原子性操作

volatile版 i++

我們再來看一個例子：

public class Test1 {

    public static volatile int val;

    public static void add() {
        for (int i = 0; i < 1000; i++) {
            val++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(Test1::add);
        Thread t2 = new Thread(Test1::add);
        t1.start();
        t2.start();
        t1.join();//等待該執行緒終止
        t2.join();
        System.out.println(val);
    }
}

2個執行緒各回圈2000次，每次+1，如果volatile關鍵字能夠保證原子性，預期的結果是2000，但實際結果卻是：1127，而且多次執行的結果都不一樣，可以發現volatile關鍵字無法保證原子性，

synchronized版 i++

我們可以利用synchronized關鍵字來解決上面的問題：

public class SynchronizedTest {
    public static int val;

    public synchronized static void add() {
        for (int i = 0; i < 1000; i++) {
            val++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(SynchronizedTest::add);
        Thread t2 = new Thread(SynchronizedTest::add);
        t1.start();
        t2.start();
        t1.join();//等待該執行緒終止
        t2.join();
        System.out.println(val);
    }
}

運行結果：2000

Lock版 i++

我們還可以通過加鎖來解決上述問題：

public class LockTest {

    public static int val;

    static Lock lock = new ReentrantLock();

    public static void add() {

        for (int i = 0; i < 1000; i++) {

            lock.lock();//上鎖
            try {
                val++;
            }catch(Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();//解鎖
            }

        }

    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(LockTest::add);
        Thread t2 = new Thread(LockTest::add);
        t1.start();
        t2.start();
        t1.join();//等待該執行緒終止
        t2.join();
        System.out.println(val);
    }

}

運行結果：2000

Atomic版 i++

Java從JDK 1.5開始提供了java.util.concurrent.atomic包（以下簡稱Atomic包），這個包中的原子操作類, 靠CAS回圈的方式來保證其原子性，是一種用法簡單、性能高效、執行緒安全地更新一個變數的方式，

這些類可以保證多執行緒環境下，當某個執行緒在執行atomic的方法時，不會被其他執行緒打斷，而別的執行緒就像自旋鎖一樣，一直等到該方法執行完成，才由JVM從等待佇列中選擇一個執行緒執行，

我們來用atomic包來解決volatile原子性的問題：

public class AtomicTest {
    public static AtomicInteger val = new AtomicInteger();

    public static void add() {
        for (int i = 0; i < 1000; i++) {
            val.getAndIncrement();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(AtomicTest::add);
        Thread t2 = new Thread(AtomicTest::add);
        t1.start();
        t2.start();
        t1.join();//等待該執行緒終止
        t2.join();
        System.out.println(val);
    }
}

運行結果：2000, 如果我們維護現有的專案，如果遇到volatile變數最好將其替換為Atomic 變數,除非你真的特別了解volatile，Atomic 就不展開說了，先挖個坑，以后補上

volatile 原理

當大家仔細讀完上文的懶漢式單例 -- 雙重校驗鎖 volatile版，會發現volatile關鍵字修飾變數后，我們反匯編后會發現多出了lock前綴指令，lock前綴指令在匯編中 LOCK指令前綴功能如下：

被修飾的匯編指令成為"原子的"
與被修飾的匯編指令一起提供"記憶體屏障"效果（lock指令可不是記憶體屏障）

記憶體屏障主要分類：

一類是可以強制讀取主記憶體，強制重繪主記憶體的記憶體屏障，叫做Load屏障和Store屏障
另一類是禁止指令重排序的記憶體屏障，主要有四個分別叫做LoadLoad屏障、StoreStore屏障、LoadStore屏障、StoreLoad屏障

這4個屏障具體作用：

LoadLoad屏障：（指令Load1; LoadLoad; Load2），在Load2及后續讀取操作要讀取的資料被訪問前，保證Load1要讀取的資料被讀取完畢，
LoadStore屏障：（指令Load1; LoadStore; Store2），在Store2及后續寫入操作被刷出前，保證Load1要讀取的資料被讀取完畢，
StoreStore屏障：（指令Store1; StoreStore; Store2），在Store2及后續寫入操作執行前，保證Store1的寫入操作對其它處理器可見，
StoreLoad屏障：（指令Store1; StoreLoad; Load2），在Load2及后續所有讀取操作執行前，保證Store1的寫入對所有處理器可見，它的開銷是四種屏障中最大的，在大多數處理器的實作中，這個屏障是個萬能屏障，兼具其它三種記憶體屏障的功能

對于volatile操作而言，其操作步驟如下：

每個volatile寫入之前，插入一個 StoreStore，寫入以后插入一個 StoreLoad
每個volatile讀取之前，插入一個 LoadLoad，讀取之后插入一個 LoadStore

我們再總結以下，用volatile關鍵字修飾變數后，主要發生的變化有哪些？：

當一個執行緒修改了 volatile 修飾的變數，當修改后的變數寫回主記憶體時，其他執行緒能立即看到最新值，即volatile關鍵字保證了并發的可見性

使用volatile關鍵字修飾共享變數后，每個執行緒要操作該變數時會從主記憶體中將變數拷貝到本地記憶體作為副本，但當執行緒操作完變數副本，會強制將修改的值立即寫入主記憶體中，

然后通過 CPU總線嗅探機制告知其他執行緒中該變數副本全部失效，（在CPU層，一個處理器的快取回寫到記憶體會導致其他處理器的快取行無效），若其他執行緒需要該變數，必須重新從主記憶體中讀取，

在x86的架構中，volatile關鍵字底層含有lock前綴的指令，與被修飾的匯編指令一起提供"記憶體屏障"效果，禁止了指令重排序，保證了并發的有序性

確保一些特定操作執行的順序,讓cpu必須按照順序執行指令，即當指令重排序時不會把其后面的指令排到記憶體屏障之前的位置，也不會把前面的指令排到記憶體屏障的后面；即在執行到記憶體屏障這句指令時，在它前面的操作已經全部完成；

volatile關鍵字無法保證原子性，更準確地說是volatile關鍵字只能保證單操作的原子性，比如 x=1，但是無法保證復合操作的原子性，比如x++，

有人可能問賦值操作是原子操作，本來就是原子性的，用volatile修飾有什么意義？
在Java 資料型別足夠大的情況下（在 Java 中 long 和 double 型別都是 64 位），寫入變數的程序分兩步進行，就會發生 Word tearing （字分裂）情況， JVM 被允許將64位數量的讀寫作為兩個單獨的32位操作執行，這增加了在讀寫程序中發生背景關系切換的可能性，多執行緒的情況下可能會出現值會被破壞的情況

在缺乏任何其他保護的情況下，用 volatile 修飾符定義一個 long 或 double 變數，可阻止字分裂情況

參考資料：

《On Java 8》

《Java并發編程》

《深入理解JVM虛擬機》

http://ifeve.com/jmm-cookbook-reorderings

http://ifeve.com/jmm-cookbook-mb

本篇文章到這里就結束啦，很感謝靚仔你能看到最后，如果覺得文章對你有幫助，別忘記關注我！更多精彩的文章

計算機內功、JAVA原始碼、職業成長、專案實戰、面試相關資料等更多精彩文章在公眾號「小牛呼嚕嚕」

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/538595.html

標籤：其他

上一篇：python中的面向物件

下一篇：使用Apache PDFBox實作拆分、合并PDF