正确理解volatile与happens-before

1. 双重校验锁实现单例的问题

在延迟实现单例时,一般代码形式如下:

 1 public class Foo {
 2     private static volatile Foo instance;
 3 
 4     public static Foo getInstance() {
 5         //第一次检查,不锁定
 6         if (null == instance) {
 7             //一旦初始化,第一次检查将无法通过,不会有锁定开销
 8             synchronized (Foo.class) {
 9                 //第二次检查,锁定
10                 if (null == instance) {
11                     instance = new Foo();
12                 }
13             }
14         }
15         return instance;
16     }
17 }

看起来很简单,但这里有个容易忽略的点,就是instance变量,需要用volatile修饰。

为什么?如果不加的话会有什么问题呢?

让我们把目光聚焦到第11行,初始化instance变量。这一行代码可以分解为如下3行伪代码。

memory = allocate(); //1. 分配对象的内存空间

ctorInstance(memory);//2. 初始化对象

instance = memory; //3.设置instance指向刚分配的内存地址

上面伪代码中的2和3,是可能会被重排序的,重排序后将变成如下时序:

memory = allocate(); //1. 分配对象的内存空间

instance = memory; //3.设置instance指向刚分配的内存地址,注意,此时对象未初始化。 

ctorInstance(memory);//2. 初始化对象

那么在多线程并发的场景下,假设有两条线程AB同时访问这个方法,可能发生以下的访问顺序:

时间                            线程A                                                     线程B

1                          分配内存空间(对应1)                       

2               设置instance指向内存空间(对应3)

3                                                                                    判断instance是否为null

4                                                                                 由于instance不为null, 不再等待进行临界区,直接访问instance引用的对象

5                           初始化对象(对应2)

这样一来,B在访问instance变量时,可能由于instance未初始化而导致出现一些异常。

那么,为什么加上volatile修饰就可以避免这种情况呢?这就涉及到happens-before和volatile的语义了。

2.happens-before与volatile语义

从JDK5开始,Java使用新的JSR-133内存模型。JSR-133使用happens-before的概念来阐述操作之间的内存可见性。在JMM中,如果一个操作执行的结果需要对另一个操作可见,以这两个操作之间必须要有happens-before关系。这里提到的两个操作,既可以是在一个线程之内,也可以是在不同的线程之间。

与程序员密切相关的happens-before规则如下。

1)程序顺序规则:一个线程中的每个操作,happens-before于该线程的任意后续操作。

2)监视器锁规则:对一个锁的解锁,happens-before于随后对这个锁的加锁。

3)volatile变量规则:对一个volatile域的写,happens-before于任意后续对这个volatile域的读。

4)传递性:如果A happens-before B,B happens-before C,那么A happens-before C.

理解volatile特性的一个好方法是把对volatile变量的单个读/写,看成是使用同一个锁对这些单个读/写操作做了同步。也就是说,对任意单个volatile变化的读/写具有原子性,但类似于volatile++这种复合操作不具有原子性。

那么上面第三条规则是怎么实现的呢?请参考:深入理解Java内存模型(四)——volatile

简单来说,就是在volatile写之后加入了一个StoreLoad屏障,防止后面的读与前面的写重排序了。这样后面的线程读到的,就是一个完整的对象。

参考:《Java并发编程的艺术》

posted @ 2018-04-05 17:35  kingsleylam  阅读(420)  评论(0编辑  收藏