問題

（1）volatile是如何保證可見性的？

（2）volatile是如何禁止重排序的？

（3）volatile的實現原理？

（4）volatile的缺陷？

簡介

volatile可以說是Java虛擬機器提供的最輕量級的同步機制了，但是它並不容易被正確地理解，以至於很多人不習慣使用它，遇到多執行緒問題一律使用synchronized或其它鎖來解決。

瞭解volatile的語義對理解多執行緒的特性具有很重要的意義，所以彤哥專門寫了一篇文章來解釋volatile的語義到底是什麼。

語義一：可見性

前面介紹Java記憶體模型的時候，我們說過可見性是指當一個執行緒修改了共享變數的值，其它執行緒能立即感知到這種變化。

關於Java記憶體模型的講解請參考【死磕 java同步系列之JMM（Java Memory Model）】。

而普通變數無法做到立即感知這一點，變數的值線上程之間的傳遞均需要通過主記憶體來完成，比如，執行緒A修改了一個普通變數的值，然後向主記憶體回寫，另外一條執行緒B只有在執行緒A的回寫完成之後再從主記憶體中讀取變數的值，才能夠讀取到新變數的值，也就是新變數才能對執行緒B可見。

在這期間可能會出現不一致的情況，比如：

（1）執行緒A並不是修改完成後立即回寫；

（線路A修改了變數x的值為5，但是還沒有回寫，執行緒B從主記憶體讀取到的還舊值0）

（2）執行緒B還在用著自己工作記憶體中的值，而並不是立即從主記憶體讀取值；

（執行緒A回寫了變數x的值為5到主記憶體中，但是執行緒B還沒有讀取主記憶體的值，依舊在使用舊值0在進行運算）

基於以上兩種情況，所以，普通變數都無法做到立即感知這一點。

但是，volatile變數可以做到立即感知這一點，也就是volatile可以保證可見性。

java記憶體模型規定，volatile變數的每次修改都必須立即回寫到主記憶體中，volatile變數的每次使用都必須從主記憶體重新整理最新的值。

volatile的可見性可以通過下面的示例體現：

public class VolatileTest {
    // public static int finished = 0;
    public static volatile int finished = 0;

    private static void checkFinished() {
        while (finished == 0) {
            // do nothing
        }
        System.out.println("finished");
    }

    private static void finish() {
        finished = 1;
    }

    public static void main(String[] args) throws InterruptedException {
        // 起一個執行緒檢測是否結束
        new Thread(() -> checkFinished()).start();

        Thread.sleep(100);

        // 主執行緒將finished標誌置為1
        finish();

        System.out.println("main finished");

    }
}
 

在上面的程式碼中，針對finished變數，使用volatile修飾時這個程式可以正常結束，不使用volatile修飾時這個程式永遠不會結束。

因為不使用volatile修飾時，checkFinished()所在的執行緒每次都是讀取的它自己工作記憶體中的變數的值，這個值一直為0，所以一直都不會跳出while迴圈。

使用volatile修飾時，checkFinished()所在的執行緒每次都是從主記憶體中載入最新的值，當finished被主執行緒修改為1的時候，它會立即感知到，進而會跳出while迴圈。

語義二：禁止重排序

前面介紹Java記憶體模型的時候，我們說過Java中的有序性可以概括為一句話：如果在本執行緒中觀察，所有的操作都是有序的；如果在另一個執行緒中觀察，所有的操作都是無序的。

前半句是指執行緒內表現為序列的語義，後半句是指“指令重排序”現象和“工作記憶體和主記憶體同步延遲”現象。

關於Java記憶體模型的講解請參考【死磕 java同步系列之JMM（Java Memory Model）】。

普通變數僅僅會保證在該方法的執行過程中所有依賴賦值結果的地方都能獲得正確的結果，而不能保證變數賦值操作的順序與程式程式碼中的執行順序一致，因為一個執行緒的方法執行過程中無法感知到這點，這就是“執行緒內表現為序列的語義”。

比如，下面的程式碼：

// 兩個操作在一個執行緒
int i = 0;
int j = 1;

上面兩句話沒有依賴關係，JVM在執行的時候為了充分利用CPU的處理能力，可能會先執行int j = 1;這句，也就是重排序了，但是線上程內是無法感知的。

看似沒有什麼影響，但是如果是在多執行緒環境下呢？

我們再看一個例子：

public class VolatileTest3 {
    private static Config config = null;
    private static volatile boolean initialized = false;

    public static void main(String[] args) {
        // 執行緒1負責初始化配置資訊
        new Thread(() -> {
            config = new Config();
            config.name = "config";
            initialized = true;
        }).start();

        // 執行緒2檢測到配置初始化完成後使用配置資訊
        new Thread(() -> {
            while (!initialized) {
                LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
            }

            // do sth with config
            String name = config.name;
        }).start();
    }
}

class Config {
    String name;
}

這個例子很簡單，執行緒1負責初始化配置，執行緒2檢測到配置初始化完畢，使用配置來幹一些事。

在這個例子中，如果initialized不使用volatile來修飾，可能就會出現重排序，比如在初始化配置之前把initialized的值設定為了true，這樣執行緒2讀取到這個值為true了，就去使用配置了，這時候可能就會出現錯誤。

（此處這個例子只是用於說明重排序，實際執行時很難出現。）

通過這個例子，彤哥相信大家對“如果在本執行緒內觀察，所有操作都是有序的；在另一個執行緒觀察，所有操作都是無序的”有了更深刻的理解。

所以，重排序是站在另一個執行緒的視角的，因為在本執行緒中，是無法感知到重排序的影響的。

而volatile變數是禁止重排序的，它能保證程式實際執行是按程式碼順序執行的。

實現：記憶體屏障

上面講了volatile可以保證可見性和禁止重排序，那麼它是怎麼實現的呢？

答案就是，記憶體屏障。

記憶體屏障有兩個作用：

（1）阻止屏障兩側的指令重排序；

（2）強制把寫緩衝區/快取記憶體中的資料回寫到主記憶體，讓快取中相應的資料失效；

關於“記憶體屏障”的知識點，各路大神的觀點也不完全一致，所以這裡彤哥也就不展開講述了，感興趣的可以看看下面的文章：

（注意，公眾號不允許外發連結，所以只能辛苦複製連結到瀏覽器中閱讀了，而且還可能需要TECH上網）

（1） Doug Lea的《The JSR-133 Cookbook for Compiler Writers》

http://g.oswego.edu/dl/jmm/cookbook.html

Doug Lea 就是java併發包的作者，大牛！

（2）Martin Thompson的《Memory Barriers/Fences》

https://mechanical-sympathy.blogspot.com/2011/07/memory-barriersfences.html

Martin Thompson 專注於把效能提升到極致，專注於從硬體層面思考問題，比如如何避免偽共享等，大牛！

它的部落格地址就是上面這個地址，裡面有很多底層的知識，有興趣的可以去看看。

（3）Dennis Byrne的《Memory Barriers and JVM Concurrency》

https://www.infoq.com/articles/memory_barriers_jvm_concurrency

這是InfoQ英文站上面的一篇文章，我覺得寫的挺好的，基本上綜合了上面的兩種觀點，並從彙編層面分析了記憶體屏障的實現。

目前國內市面上的關於記憶體屏障的講解基本不會超過這三篇文章，包括相關書籍中的介紹。

我們還是來看一個例子來理解記憶體屏障的影響：

public class VolatileTest4 {
    // a不使用volatile修飾
    public static long a = 0;
    // 消除快取行的影響
    public static long p1, p2, p3, p4, p5, p6, p7;
    // b使用volatile修飾
    public static volatile long b = 0;
    // 消除快取行的影響
    public static long q1, q2, q3, q4, q5, q6, q7;
    // c不使用volatile修飾
    public static long c = 0;

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while (a == 0) {
                long x = b;
            }
            System.out.println("a=" + a);
        }).start();

        new Thread(()->{
            while (c == 0) {
                long x = b;
            }
            System.out.println("c=" + c);
        }).start();

        Thread.sleep(100);

        a = 1;
        b = 1;
        c = 1;
    }
}

這段程式碼中，a和c不使用volatile修飾，b使用volatile修飾，而且我們在a/b、b/c之間各加入7個long欄位消除偽共享的影響。

關於偽共享的相關知識，可以檢視彤哥之前寫的文章【雜談 什麼是偽共享（false sharing）？】。

在a和c的兩個執行緒的while迴圈中我們獲取一下b，你猜怎樣？如果把long x = b;這行去掉呢？執行試試吧。

彤哥這裡直接說結論了：volatile變數的影響範圍不僅僅只包含它自己，它會對其上下的變數值的讀寫都有影響。

缺陷

上面我們介紹了volatile關鍵字的兩大語義，那麼，volatile關鍵字是不是就是萬能的了呢？

當然不是，忘了我們記憶體模型那章說的一致性包括的三大特性了麼？

一致性主要包含三大特性：原子性、可見性、有序性。

volatile關鍵字可以保證可見性和有序性，那麼volatile能保證原子性麼？

請看下面的例子：

public class VolatileTest5 {
    public static volatile int counter = 0;

    public static void increment() {
        counter++;
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(100);
        IntStream.range(0, 100).forEach(i->
                new Thread(()-> {
                    IntStream.range(0, 1000).forEach(j->increment());
                    countDownLatch.countDown();
                }).start());

        countDownLatch.await();

        System.out.println(counter);
    }
}

這段程式碼中，我們起了100個執行緒分別對counter自增1000次，一共應該是增加了100000，但是實際執行結果卻永遠不會達到100000。

讓我們來看看increment()方法的位元組碼（IDEA下載相關外掛可以檢視）：

0 getstatic #2 <com/coolcoding/code/synchronize/VolatileTest5.counter>
3 iconst_1
4 iadd
5 putstatic #2 <com/coolcoding/code/synchronize/VolatileTest5.counter>
8 return

可以看到counter++被分解成了四條指令：

（1）getstatic，獲取counter當前的值併入棧

（2）iconst_1，入棧int型別的值1

（3）iadd，將棧頂的兩個值相加

（4）putstatic，將相加的結果寫回到counter中

由於counter是volatile修飾的，所以getstatic會從主記憶體重新整理最新的值，putstatic也會把修改的值立即同步到主記憶體。

但是中間的兩步iconst_1和iadd在執行的過程中，可能counter的值已經被修改了，這時並沒有重新讀取主記憶體中的最新值，所以volatile在counter++這個場景中並不能保證其原子性。

volatile關鍵字只能保證可見性和有序性，不能保證原子性，要解決原子性的問題，還是隻能通過加鎖或使用原子類的方式解決。

進而，我們得出volatile關鍵字使用的場景：

（1）運算的結果並不依賴於變數的當前值，或者能夠確保只有單一的執行緒修改變數的值；

（2）變數不需要與其他狀態變數共同參與不變約束。

說白了，就是volatile本身不保證原子性，那就要增加其它的約束條件來使其所在的場景本身就是原子的。

比如：

private volatile int a = 0;

// 執行緒A
a = 1;

// 執行緒B
if (a == 1) {
    // do sth
}

a = 1;這個賦值操作本身就是原子的，所以可以使用volatile來修飾。

總結

（1）volatile關鍵字可以保證可見性；

（2）volatile關鍵字可以保證有序性；

（3）volatile關鍵字不可以保證原子性；

（4）volatile關鍵字的底層主要是通過記憶體屏障來實現的；

（5）volatile關鍵字的使用場景必須是場景本身就是原子的；

彩蛋

關於“記憶體屏障”的三篇文章，考慮到有的同學無法TECH上網，彤哥專門把這三篇下載下來整理了一下。

關注我的公眾號“彤哥讀原始碼”，後臺回覆“volatile”，下載這三篇資料。

---

歡迎關注我的公眾號“彤哥讀原始碼”，檢視更多原始碼系列文章, 與彤哥一起暢遊原始碼的海洋。

相關推薦