詳解volatile的使用及其原理分析

一、volatile的作用

　　在《Java並發程式設計：核心理論》一文中，我們已經提到過可見性、有序性及原子性問題，通常情況下我們可以透過Synchronized關鍵字來解決這些個問題，不過如果對Synchronized原理有了解的話，應該知道Synchronized是一個比較重量級的操作，對系統的性能有比較大的影響，所以，如果有其他解決方案，我們通常都避免使用Synchronized來解決問題。而volatile關鍵字就是Java中提供的另一種解決可見性和有序性問題的方案。對於原子性，需要強調一點，也是大家容易誤解的一點：對volatile變量的單次讀/寫操作可以保證原子性的，如long和double類型變量，但是並不能保證i++這種操作的原子性，因為本質上i++是讀、寫兩次操作。

二、volatile的使用

　　關於volatile的使用，我們可以透過幾個例子來說明其使用方式和場景。

1、防止重排序

　　我們從一個最經典的例子來分析重新排序問題。大家應該都很熟悉單例模式的實現，而在並發環境下的單例實現方式，我們通常可以採用雙重檢查加鎖（DCL）的方式來實現。其原始碼如下：

 1 package com.paddx.test.concurrent;
 2 
 3 public class Singleton {
 4     public static volatile Singleton singleton;
 5 
 6     /**
 7      * 构造函数私有，禁止外部实例化
 8      */
 9     private Singleton() {};
10 
11     public static Singleton getInstance() {
12         if (singleton == null) {
13             synchronized (singleton) {
14                 if (singleton == null) {
15                     singleton = new Singleton();
16                 }
17             }
18         }
19         return singleton;
20     }
21 }

##　　現在我們分析一下為什麼要在變數singleton之間加上volatile關鍵字。要理解這個問題，先要了解物件的建構過程，實例化一個物件其實可以分成三個步驟：

　　（1）分配記憶體空間。

　　（2）初始化物件。

　　（3）將記憶體空間的位址賦值給對應的參考。

但是由於作業系統可以對指令進行重新排序，所以上面的過程也可能會變成以下過程：

　　（1）分配記憶體空間。

　　（2）將記憶體空間的位址賦值給對應的參考。

　　（3）初始化物件

　　如果是這個流程，多執行緒環境下就可能將一個未初始化的物件參考暴露出來，從而導致不可預料的結果。因此，為了防止這個過程的重排序，我們需要將變數設定為volatile類型的變數。

2、實作可見性

　　可見性問題主要指一個執行緒修改了共享變數值，而另一個執行緒卻看不到。造成可見性問題的主要原因是每個執行緒擁有自己的一個高速緩存區——線程工作記憶體。 volatile關鍵字能有效的解決這個問題，我們看下下面的例子，就可以知道其作用：

 1 package com.paddx.test.concurrent;
 2 
 3 public class VolatileTest {
 4     int a = 1;
 5     int b = 2;
 6 
 7     public void change(){
 8         a = 3;
 9         b = a;
10     }
11 
12     public void print(){
13         System.out.println("b="+b+";a="+a);
14     }
15 
16     public static void main(String[] args) {
17         while (true){
18             final VolatileTest test = new VolatileTest();
19             new Thread(new Runnable() {
20                 @Override
21                 public void run() {
22                     try {
23                         Thread.sleep(10);
24                     } catch (InterruptedException e) {
25                         e.printStackTrace();
26                     }
27                     test.change();
28                 }
29             }).start();
30 
31             new Thread(new Runnable() {
32                 @Override
33                 public void run() {
34                     try {
35                         Thread.sleep(10);
36                     } catch (InterruptedException e) {
37                         e.printStackTrace();
38                     }
39                     test.print();
40                 }
41             }).start();
42 
43         }
44     }
45 }

　　直观上说，这段代码的结果只可能有两种：b=3;a=3 或 b=2;a=1。不过运行上面的代码（可能时间上要长一点），你会发现除了上两种结果之外，还出现了第三种结果：

...... 
b=2;a=1
b=2;a=1
b=3;a=3
b=3;a=3
b=3;a=1
b=3;a=3
b=2;a=1
b=3;a=3
b=3;a=3
......

　　为什么会出现b=3;a=1这种结果呢？正常情况下，如果先执行change方法，再执行print方法，输出结果应该为b=3;a=3。相反，如果先执行的print方法，再执行change方法，结果应该是 b=2;a=1。那b=3;a=1的结果是怎么出来的？原因就是第一个线程将值a=3修改后，但是对第二个线程是不可见的，所以才出现这一结果。如果将a和b都改成volatile类型的变量再执行，则再也不会出现b=3;a=1的结果了。

3、保证原子性

 　　关于原子性的问题，上面已经解释过。volatile只能保证对单次读/写的原子性。这个问题可以看下JLS中的描述：

17.7 Non-Atomic Treatment of double and long

For the purposes of the Java programming language memory model, a single write to a non-volatile long or double value is treated as two separate writes: one to each 32-bit half. This can result in a situation where a thread sees the first 32 bits of a 64-bit value from one write, and the second 32 bits from another write.

Writes and reads of volatile long and double values are always atomic.

Writes to and reads of references are always atomic, regardless of whether they are implemented as 32-bit or 64-bit values.

Some implementations may find it convenient to divide a single write action on a 64-bit long or double value into two write actions on adjacent 32-bit values. For efficiency's sake, this behavior is implementation-specific; an implementation of the Java Virtual Machine is free to perform writes to long and double values atomically or in two parts.

Implementations of the Java Virtual Machine are encouraged to avoid splitting 64-bit values where possible. Programmers are encouraged to declare shared 64-bit values as volatile or synchronize their programs correctly to avoid possible complications.

　　这段话的内容跟我前面的描述内容大致类似。因为long和double两种数据类型的操作可分为高32位和低32位两部分，因此普通的long或double类型读/写可能不是原子的。因此，鼓励大家将共享的long和double变量设置为volatile类型，这样能保证任何情况下对long和double的单次读/写操作都具有原子性。

　　关于volatile变量对原子性保证，有一个问题容易被误解。现在我们就通过下列程序来演示一下这个问题：

 1 package com.paddx.test.concurrent;
 2 
 3 public class VolatileTest01 {
 4     volatile int i;
 5 
 6     public void addI(){
 7         i++;
 8     }
 9 
10     public static void main(String[] args) throws InterruptedException {
11         final  VolatileTest01 test01 = new VolatileTest01();
12         for (int n = 0; n <div class="cnblogs_code_toolbar"><span class="cnblogs_code_copy"><img src="https://img.php.cn/upload/article/000/000/001/0313942818f37f12b8713dd37831b872-5.gif" alt="詳解volatile的使用及其原理分析"></span></div>

大家可能會誤以為對變數i加上關鍵字volatile後，這段程式就是執行緒安全的。大家可以嘗試執行上面的程式。以下是我本地運行的結果：

　　可能每個人運行的結果都不相同。不過應該可以看出，volatile是無法保證原子性的（否則結果應該是1000）。原因也很簡單，i++其實是一個複合操作，包含三個步驟：

　　（1）讀取i的值。

　　（2）對i加1。

　　（3）將i的值寫回記憶體。

volatile是無法保證這三個操作是具有原子性的，我們可以透過AtomicInteger或Synchronized來保證+1操作的原子性。

註：上面幾段程式碼中多處執行了Thread.sleep()方法，目的是為了增加並發問題的產生幾率，沒有其他作用。

三、volatile的原理

　　透過上面的例子，我們基本上應該知道了volatile是什麼以及怎麼使用。現在我們再來看看volatile的底層是怎麼實現的。

　　1、可見性實作：

　　在前文中已經提及過，執行緒本身並沒有直接與主記憶體進行資料的交互，而是透過執行緒的工作記憶體來完成對應的操作。這也是導致線程間資料不可見的本質原因。因此要實現volatile變數的可見性，直接從這方面入手即可。 volatile變數的寫入操作與普通變數的主要差異有兩點：

　　（1）修改volatile變數時會強制將修改後的值刷新的主記憶體中。

　　（2）修改volatile變數後會導致其他執行緒工作記憶體中對應的變數值失效。因此，再讀取該變數值的時候就需要重新從讀取主記憶體中的值。

　　透過這兩個操作，就可以解決volatile變數的可見性問題。

　　2、有序性實作：

 　　在解釋這個問題前，我們先來了解一下Java中的happen-before規則，JSR 133中對Happen- before的定義如下：

Two actions can be ordered by a happens-before relationship.If one action happens before another, then the first is visible to and ordered before the second.

##　　　通通一點一點。說就是如果a happen-before b，則a所做的任何操作對b是可見的。 （這一點大家務必記住，因為happen-before這個字容易被誤解為是時間的前後）。我們再來看看JSR 133中定義了哪些happen-before規則：

• Each action in a thread happens before every subsequent action in that thread. 

• An unlock on a monitor happens before every subsequent every subsequent on that monitor. 
• A write to a volatile field happens before every subsequent read of that volatile. 
• A call to start() on a thread happens before any actions in the started thread. actions in a thread happen before any other thread successfully returns from a join() on that thread. 
• If an action a happens before an action b, and b happens before an action, then a happens c, then c.
#　　翻譯過來為：

同一個執行緒中的，前面的操作happen-before 後續的操作。 （即單執行緒內按程式碼順序執行。但是，在不影響在單執行緒環境執行結果的前提下，編譯器和處理器可以進行重排序，這是合法的。換句話說，這項是規則無法保證編譯重排和指令重排）。

• 監視器上的解鎖操作 happen-before 其後續的加鎖操作。 （Synchronized 規則）

• 對volatile變數的寫入操作 happen-before 後續的讀取操作。 （volatile 規則）

• 線程的start() 方法 happen-before 該線程所有的後續操作。 （執行緒啟動規則）

• 執行緒所有的操作 happen-before 其他執行緒在該執行緒上呼叫 join 回傳成功後的操作。

• 如果 a happen-before b，b happen-before c，則a happen-before c（傳遞性）。

• 　　這裡我們主要看下第三條：volatile變數的保證有序性的規則。 《Java並發程式設計：核心理論》一文中提到過重排序分為編譯器重新排序與處理器重排序。為了實作volatile記憶體語義，JMM會對volatile變數限制這兩種類型的重排序。以下是JMM針對volatile變數所規定的重排序規則表：

Can Reorder	2nd operation
1st operation	Normal Load Normal Store	Volatile Load	Volatile Store
Normal Load Normal Store			No
Volatile Load	No	No	No
Volatile store		No	No

　　3、内存屏障

　　为了实现volatile可见性和happen-befor的语义。JVM底层是通过一个叫做“内存屏障”的东西来完成。内存屏障，也叫做内存栅栏，是一组处理器指令，用于实现对内存操作的顺序限制。下面是完成上述规则所要求的内存屏障：

Required barriers	2nd operation
1st operation	Normal Load	Normal Store	Volatile Load	Volatile Store
Normal Load				LoadStore
Normal Store				StoreStore
Volatile Load	LoadLoad	LoadStore	LoadLoad	LoadStore
Volatile Store			StoreLoad	StoreStore

（1）LoadLoad 屏障
执行顺序：Load1—>Loadload—>Load2
确保Load2及后续Load指令加载数据之前能访问到Load1加载的数据。

（2）StoreStore 屏障
执行顺序：Store1—>StoreStore—>Store2
确保Store2以及后续Store指令执行前，Store1操作的数据对其它处理器可见。

（3）LoadStore 屏障
执行顺序： Load1—>LoadStore—>Store2
确保Store2和后续Store指令执行前，可以访问到Load1加载的数据。

（4）StoreLoad 屏障
执行顺序: Store1—> StoreLoad—>Load2
确保Load2和后续的Load指令读取之前，Store1的数据对其他处理器是可见的。

最后我可以通过一个实例来说明一下JVM中是如何插入内存屏障的：


 1 package com.paddx.test.concurrent;
 2 
 3 public class MemoryBarrier {
 4     int a, b;
 5     volatile int v, u;
 6 
 7     void f() {
 8         int i, j;
 9 
10         i = a;
11         j = b;
12         i = v;
13         //LoadLoad
14         j = u;
15         //LoadStore
16         a = i;
17         b = j;
18         //StoreStore
19         v = i;
20         //StoreStore
21         u = j;
22         //StoreLoad
23         i = u;
24         //LoadLoad
25         //LoadStore
26         j = b;
27         a = i;
28     }
29 }


四、总结

　　总体上来说volatile的理解还是比较困难的，如果不是特别理解，也不用急，完全理解需要一个过程，在后续的文章中也还会多次看到volatile的使用场景。这里暂且对volatile的基础知识和原来有一个基本的了解。总体来说，volatile是并发编程中的一种优化，在某些场景下可以代替Synchronized。但是，volatile的不能完全取代Synchronized的位置，只有在一些特殊的场景下，才能适用volatile。总的来说，必须同时满足下面两个条件才能保证在并发环境的线程安全：

　　（1）对变量的写操作不依赖于当前值。

　　（2）该变量没有包含在具有其他变量的不变式中。

以上是詳解volatile的使用及其原理分析的詳細內容。更多資訊請關注PHP中文網其他相關文章！