Java 并发编程：volatile的使用及其原理

Java并发编程系列：

• Java 并发编程：核心理论 

• Java并发编程：Synchronized及其实现原理

• Java并发编程：Synchronized底层优化（轻量级锁、偏向锁）

• Java 并发编程：线程间的协做(wait/notify/sleep/yield/join)

• Java 并发编程：volatile的使用及其原理

 1、volatile的做用

　　在《Java并发编程：核心理论》一文中，咱们已经提到过可见性、有序性及原子性问题，一般状况下咱们能够经过Synchronized关键字来解决这些个问题，不过若是对Synchronized原理有了解的话，应该知道Synchronized是一个比较重量级的操做，对系统的性能有比较大的影响，因此，若是有其余解决方案，咱们一般都避免使用Synchronized来解决问题。而volatile关键字就是Java中提供的另外一种解决可见性和有序性问题的方案。对于原子性，须要强调一点，也是你们容易误解的一点：对volatile变量的单次读/写操做能够保证原子性的，如long和double类型变量，可是并不能保证i++这种操做的原子性，由于本质上i++是读、写两次操做。

2、volatile的使用

　　关于volatile的使用，咱们能够经过几个例子来讲明其使用方式和场景。

一、防止重排序

　　咱们从一个最经典的例子来分析重排序问题。你们应该都很熟悉单例模式的实现，而在并发环境下的单例实现方式，咱们一般能够采用双重检查加锁（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类型的变量。

二、实现可见性

　　可见性问题主要指一个线程修改了共享变量值，而另外一个线程却看不到。引发可见性问题的主要缘由是每一个线程拥有本身的一个高速缓存区——线程工做内存。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的结果了。

三、保证原子性

 　　关于原子性的问题，上面已经解释过。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 < 1000; n++) {
13             new Thread(new Runnable() {
14                 @Override
15                 public void run() {
16                     try {
17                         Thread.sleep(10);
18                     } catch (InterruptedException e) {
19                         e.printStackTrace();
20                     }
21                     test01.addI();
22                 }
23             }).start();
24         }
25 
26         Thread.sleep(10000);//等待10秒，保证上面程序执行完成
27 
28         System.out.println(test01.i);
29     }
30 }

你们可能会误认为对变量i加上关键字volatile后，这段程序就是线程安全的。你们能够尝试运行上面的程序。下面是我本地运行的结果：

　　可能每一个人运行的结果不相同。不过应该能看出，volatile是没法保证原子性的（不然结果应该是1000）。缘由也很简单，i++实际上是一个复合操做，包括三步骤：

　　（1）读取i的值。

　　（2）对i加1。

　　（3）将i的值写回内存。

volatile是没法保证这三个操做是具备原子性的，咱们能够经过AtomicInteger或者Synchronized来保证+1操做的原子性。

注：上面几段代码中多处执行了Thread.sleep()方法，目的是为了增长并发问题的产生概率，无其余做用。

3、volatile的原理

　　经过上面的例子，咱们基本应该知道了volatile是什么以及怎么使用。如今咱们再来看看volatile的底层是怎么实现的。

　　一、可见性实现：

　　在前文中已经说起过，线程自己并不直接与主内存进行数据的交互，而是经过线程的工做内存来完成相应的操做。这也是致使线程间数据不可见的本质缘由。所以要实现volatile变量的可见性，直接从这方面入手便可。对volatile变量的写操做与普通变量的主要区别有两点：

　　（1）修改volatile变量时会强制将修改后的值刷新的主内存中。

　　（2）修改volatile变量后会致使其余线程工做内存中对应的变量值失效。所以，再读取该变量值的时候就须要从新从读取主内存中的值。

　　经过这两个操做，就能够解决volatile变量的可见性问题。

　　二、有序性实现：

 　　在解释这个问题前，咱们先来了解一下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 lock 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.
• All 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 c, then a happens before 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

　　三、内存屏障

　　为了实现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 }

4、总结

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

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

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