volatile 關鍵字是 Java 語言的高級特性，但要弄清楚其工作原理，需要先弄懂 Java 內存模型。

初學 volatile 關鍵字，我們需要弄清楚它到底意味著什么。總的來說，它有兩個含義，分別是：

• 保證可見性
• 禁止指令重排序

保證可見性

保證可見性指的是：當一個線程修改了某個變量時，其他所有線程都知道該變量被修改了。 由于 volatile 可以保證可見性，因此 Java 能夠保證現(xiàn)在在讀取 volatile 變量時，線程讀取到的值是準確的。但是這并不意味著對 volatile 變量的操作是線程安全的，因為有可能在讀取到變量之后，又有其他線程對變量進行修改了。

為了說明這個問題，我們可以舉個簡單地例子。下面代碼發(fā)起了 20 個線程，每個線程對 race 變量進行 1 萬次自增操作。如果這段代碼能夠正確并發(fā)執(zhí)行，那么最后輸出的結果應該是 20 萬。但實際上，每次輸出的結果都不一樣，都是一個小于 20 萬的數(shù)字，為什么呢？

這是因為當線程在獲取到 race 變量的值，然后對其進行自增這中間，有可能其他線程對 race 變量做了自增操作，然后寫回了主內存。而當前線程再將數(shù)據(jù)寫回主內存時，就發(fā)生了數(shù)據(jù)覆蓋。因此，就發(fā)生了數(shù)據(jù)不一致的問題。

要使得 volatile 變量不發(fā)生并發(fā)安全問題，只需要遵守如下兩條規(guī)則即可：

運算結果并不依賴變量的當前值，或者能夠確保只有單一的線程修改變量的值。

變量不需要與其他的狀態(tài)變量共同參與不變約束。

第一條規(guī)則比較好理解，例如上面例子的 race 變量，其運算結果就依賴于變量的當前值，所以其并不符合第一條規(guī)則，因此就會有線程安全問題。但如果 race++? 變成了 race=1; 這樣的情況，那么 race 的值就不依賴變量當前值，因此就不會有線程安全問題。

第二條規(guī)則有點晦澀難懂。其意思是說，變量不能和其他變量一起參與判斷，無論其他變量是否是 volatile 類型的變量。例如 if（a && b） 這個判斷就無法滿足 volatile 的第二條規(guī)則，會發(fā)生線程安全問題，即使這兩個變量都是 volatile 類型的變量。

關于第二條規(guī)則的描述，為啥與其他變量一起，就沒法保證線程安全呢？

要解答這個問題，我們不妨假設一下各種可能的場景。

我們假設變量 a b 的初始值都是 true，并且兩者都是 volatile 類型變量。

場景一：線程 A 執(zhí)行 if（a && b） 判斷，先判斷變量 a，發(fā)現(xiàn)是 true，于是繼續(xù)判斷變量 b。發(fā)現(xiàn)變量 b 也是 true，于是整個表達式為 true。

場景二：線程 A 執(zhí)行 if（a && b） 判斷，先判斷變量 a，發(fā)現(xiàn)是 true。此時線程 B 修改了變量 b 的值為 false。接著線程 A 繼續(xù)判斷變量 b 的值，發(fā)現(xiàn)變量 b 的值為 false。于是整體表達式的值為 false。

通過上面的例子，我們發(fā)現(xiàn)同樣的表達式在不同的并發(fā)場景下會有不同的結果，這很明顯就是線程不安全的。因為線程安全的代碼，在單線程和多線程下，其結果應該是一樣的。

禁止指令重排序

指令重排序，指的是硬件層面為了加快執(zhí)行速度，可能會調整指令的執(zhí)行順序，從而會出現(xiàn)并不按代碼順序的執(zhí)行情況出現(xiàn)。例如下面的代碼里，我們初始化了 flag 變量為 false，然后再將 flag 變量置為 true。但這樣的代碼在并發(fā)執(zhí)行的時候，有可能先將 flag 職位 true，再將 flag 變?yōu)?false，從而發(fā)生線程安全問題。

boolean flag = false;
flag = true;

我們說 volatile 變量禁止指令重排序，其實就是指被 volatile 修飾的變量，其執(zhí)行順序不能被重排序。 禁止重排序的實現(xiàn)，是使用了一個叫「內存屏障」的東西。簡單地說，內存屏障的作用就是指令重排序時，不能把后面的指令重排序到內存屏障之前的位置。

可見性的來源

我們前面說過：volatile 修飾的變量，當其被修改之后，其他變量就能立即獲取到其變化。但這個可見性的來源是哪里呢？為什么其能夠實現(xiàn)這樣的可見性呢？其實 volatile 的這些功能來源于 Java 內存模型中對 volatile 變量定義的特殊規(guī)則。

假定 T 表示一個線程，V 和 W 分別表示兩個 volatile 型變量。在 Java 內存模型中規(guī)定在進行 read、load、use、assign、store 和 write 操作時需要滿足如下規(guī)則：

• 只有當線程 T 對變量 V 執(zhí)行的前一個動作是 load 的時候，線程 T 才能對變量 V 執(zhí)行 use 動作。并且，只有當線程 T 對變量 V 執(zhí)行的后一個動作是 use 的時候，線程 T 才能對變量 V 執(zhí)行 load 動作。
• 只有當線程 T 對變量 V 執(zhí)行的前一個動作是 assign 的時候，線程 T 才能對變量 V 執(zhí)行 store 動作；并且，只有當線程 T 對變量 V 執(zhí)行的后一個動作是 store 的時候，線程 T 才能對變量 V 執(zhí)行 assign 動作。
• 假定動作 A 是線程 T 對變量 V 實施的 use 或 assign 動作，假定動作 F 是和動作 A 相關聯(lián)的 load 或 store 動作，假定動作 P 是和動作 F 相應的對變量 V 的 read 或 write 動作。類似的，假定動作 B 是線程 T 對變量 W 實施的 use 或 assign 動作，假定動作 G 是和動作 B 相關聯(lián)的 load 或 store 動作，假定動作 Q 是和動作 G 相應的對變量 W 的 read 或 write 動作。如果 A 先于 B，那么 P 先于 Q。

上面三條規(guī)則有點復雜，我們來一條條講解下。

首先，我們來看看第一條規(guī)則。

只有當線程 T 對變量 V 執(zhí)行的前一個動作是 load 的時候，線程 T 才能對變量 V 執(zhí)行 use 動作。

load 動作，指的是把從主內存得到的變量值，放入到工作內存的變量副本。use 動作，指的是將工作內存的一個變量值，傳遞給執(zhí)行引擎。那么這句話合起來的意思可以理解為：要使用變量 V 之前，必須去主內存讀取變量 V。

并且，只有當線程 T 對變量 V 執(zhí)行的后一個動作是 use 的時候，線程 T 才能對變量 V 執(zhí)行 load 動作。

這句的意思可以理解為：要去讀取主內存的變量值放入工作內存的變量副本，那就必須使用它。

總的來說，這條規(guī)則的意思是：線程對變量 V 的 use 動作，必須與 read、load 動作連在一起，即 read -> load -> use 必須一起出現(xiàn)。這條規(guī)則要求在工作內存中，每次使用 V 前都必須先從主內存刷新最新的值，用于保證能看見其他線程對變量 V 所做的修改后的值。

我們繼續(xù)看第二條規(guī)則。

只有當線程 T 對變量 V 執(zhí)行的前一個動作是 assign 的時候，線程 T 才能對變量 V 執(zhí)行 store 動作。

assign 動作，指的是將執(zhí)行引擎的值賦值給工作內存的變量。store 動作，指的是將工作內存的一個變量傳送到主內存，方便后續(xù)寫回主內存。那么這句話合起來的意思可以理解為：要講工作內存的變量寫回主內存，那么必須是工作內存的變量收到執(zhí)行引擎的賦值。

并且，只有當線程 T 對變量 V 執(zhí)行的后一個動作是 store 的時候，線程 T 才能對變量 V 執(zhí)行 assign 動作。

這句話的意思可以理解為：要將執(zhí)行引擎接收到的值賦給工作內存的變量，就必須把工作內存變量的值寫回主內存。

總的來說，這條規(guī)則的意思是：線程對變量 V 的 assign 動作，必須與 store、write 連在一起，即：assign -> store -> write 必須一起出現(xiàn)。這條規(guī)則要求在工作內存中，每次修改 V 后都必須立刻同步回主內存中，用于保證其他線程可以看到自己對變量 V 所做的修改。

我們繼續(xù)看第三條規(guī)則。

假定動作 A 是線程 T 對變量 V 實施的 use 或 assign 動作，假定動作 F 是和動作 A 相關聯(lián)的 load 或 store 動作，假定動作 P 是和動作 F 相應的對變量 V 的 read 或 write 動作。

這句話意思比較簡單，use 和 assign 動作分別是從工作內存?zhèn)鬟f變量給執(zhí)行引擎，以及從執(zhí)行引擎?zhèn)鬟f變量給工作內存。load 和 store 動作分別是從主內存載入數(shù)據(jù)到工作內存，以及從工作內存寫數(shù)據(jù)到主內存。read 和 write 動作分別是將數(shù)據(jù)讀取到工作內存，以及將數(shù)據(jù)寫回主內存。

我們假設是一個寫入到主內存動作，如果這幾個組合起來，那么就是：A -> F -> P（assign -> store -> write）。

類似的，假定動作 B 是線程 T 對變量 W 實施的 use 或 assign 動作，假定動作 G 是和動作 B 相關聯(lián)的 load 或 store 動作，假定動作 Q 是和動作 G 相應的對變量 W 的 read 或 write 動作。

與上面類似，如果是一個寫入到主內存動作，如果這幾個組合起來，那么就是：B -> G -> Q（assign -> store -> write）。

如果 A 先于 B，那么 P 先于 Q。

這個的意思是，如果 A 動作早于 B 動作發(fā)生，那么 A 動作對應的 P 動作（write 動作）就要早于 Q 動作 (write 動作）。

這條規(guī)則要求 volatile 修飾的變量不會被指令重排序優(yōu)化，保證代碼的執(zhí)行順序與程序的順序相同。

所以說 volatile 變量的可見性以及禁止重排序的語義，其實都來源于 Java 內存模型里對于 volatile 變量的定義。

總結

這篇文章，我們介紹了 volatile 的兩個語義：

• 可見性
• 禁止重排序

可見性指的是 volatile 類型的變量，其變量值一旦被修改，其他線程就能夠立刻感知到。而禁止重排序指的是被 volatile 修飾的變量，其執(zhí)行順序不能被重排序。我們在日常使用中，如果要使 volatile 變量不發(fā)生線程安全問題，只需要遵守下面兩個規(guī)則即可。

• 運算結果并不依賴變量的當前值，或者能夠確保只有單一的線程修改變量的值。
• 變量不需要與其他的狀態(tài)變量共同參與不變約束。

最后，我們進一步探究了 volatile 可見性以及禁止重排序的來源，其實就是 Java 內存模型里對于 volatile 變量的定義。