2.2 指令重排&happens-before 原则 & 内存屏障教程

一. 指令重排

令重排序:java语言规范规定JVM线程内部维持顺序化语义。即只要程序的最终结果 与它顺序化情况的结果相等，那么指令的执行顺序可以与代码顺序不一致，此过程叫指令的 重排序。

指令重排序的意义是什么?

JVM能根据处理器特性(CPU多级缓存系统、多核处 理器等)适当的对机器指令进行重排序，使机器指令能更符合CPU的执行特性，最大限度的 发挥机器性能。

  <br></br>下图为从源码到最终执行的指令序列示意图:

1.1. as-if-serial

语义 as-if-serial语义的意思是:不管怎么重排序(编译器和处理器为了提高并行度)，(单线程)程序的执行结果不能被改变。编译器、runtime和处理器都必须遵守as-if-serial语 义。

为了遵守as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操作做重排序， 因为这种重排序会改变执行结果。但是，如果操作之间不存在数据依赖关系，这些操作就可 能被编译器和处理器重排序。

1.2. happens-before 原则

只靠sychronized和volatile关键字来保证原子性、可见性以及有序性，那么编写并发 程序可能会显得十分麻烦，幸运的是，从JDK 5开始，Java使用新的JSR-133内存模型，提 供了happens-before 原则来辅助保证程序执行的原子性、可见性以及有序性的问题，它是 判断数据是否存在竞争、线程是否安全的依据，happens-before 原则内容如下

1. 程序顺序原则

即在一个线程内必须保证语义串行性，也就是说按照代码顺序执行。

2. 锁规则

解锁(unlock)操作必然发生在后续的同一个锁的加锁(lock)之前，也就是 说，如果对于一个锁解锁后，再加锁，那么加锁的动作必须在解锁动作之后(同一个 锁)。

3. volatile规则

volatile变量的写，先发生于读，这保证了volatile变量的可见性，简 单的理解就是，volatile变量在每次被线程访问时，都强迫从主内存中读该变量的 值，而当该变量发生变化时，又会强迫将最新的值刷新到主内存，任何时刻，不同的 线程总是能够看到该变量的最新值。

4. 线程启动规则

线程的start()方法先于它的每一个动作，即如果线程A在执行线程B 的start方法之前修改了共享变量的值，那么当线程B执行start方法时，线程A对共享 变量的修改对线程B可见

5. 传递性

A先于B ，B先于C 那么A必然先于C

6. 线程终止规则

线程的所有操作先于线程的终结，Thread.join()方法的作用是等待 当前执行的线程终止。假设在线程B终止之前，修改了共享变量，线程A从线程B的 join方法成功返回后，线程B对共享变量的修改将对线程A可见。

7. 线程中断规则

对线程 interrupt()方法的调用先行发生于被中断线程的代码检测到 中断事件的发生，可以通过Thread.interrupted()方法检测线程是否中断。

8. 对象终结规则

对象的构造函数执行，结束先于finalize()方法

二. volatile内存语义

volatile是Java虚拟机提供的轻量级的同步机制。

2.1 volatile关键字有两个作用

1. 保证被volatile修饰的共享变量对所有线程总数可见的，也就是当一个线程修改了一个被volatile修饰共享变量的值，新值总是可以被其他线程立即得知。

2. 禁止指令重排序优化。

2.2 volatile的可见性

关于volatile的可见性作用，我们必须意识到被volatile修饰的变量对所有线程总是立即可见的，对volatile变量的所有写操作总是能立刻反应到其他线程中

2.3 volatile无法保证原子性

代码

在并发场景下，i变量的任何改变都会立马反应到其他线程中，但是如此存在多条线程 同时调用increase()方法的话，就会出现线程安全问题，毕竟i++;操作并不具备原子性，该 操作是先读取值，然后写回一个新值，相当于原来的值加上1，分两步完成，如果第二个线 程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程 一起看到同一个值，并执行相同值的加1操作，这也就造成了线程安全失败，因此对于 increase方法必须使用synchronized修饰，以便保证线程安全，需要注意的是一旦使用 synchronized修饰方法后，由于synchronized本身也具备与volatile相同的特性，即可见 性，因此在这样种情况下就完全可以省去volatile修饰变量。

2.4 volatile禁止指令重排

volatile关键字另一个作用就是禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象，关于指令重排优化前面已详细分析过，这里主要简单说明一下volatile是如 何实现禁止指令重排优化的。先了解一个概念，内存屏障(Memory Barrier)。

三. 硬件层的内存屏障

Intel硬件提供了一系列的内存屏障，主要有:

1. lfence，是一种Load Barrier 读屏障
2. sfence, 是一种Store Barrier 写屏障
3. mfence, 是一种全能型的屏障，具备ifence和sfence的能力
4. Lock前缀，Lock不是一种内存屏障，但是它能完成类似内存屏障的功能。Lock会对 CPU总线和高速缓存加锁，可以理解为CPU指令级的一种锁。它后面可以跟ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG, CMPXCH8B, DEC, INC, NEG, NOT, OR, SBB, SUB, XOR, XADD, and XCHG等指令。

不同硬件实现内存屏障的方式不同，Java内存模型屏蔽了这种底层硬件平台的差异，由 JVM来为不同的平台生成相应的机器码。 JVM中提供了四类内存屏障指令:

屏障类型 指令示例 说明 LoadLoad Load1; LoadLoad; Load2 保证load1的读取操作在load2及后续读取操作之前执行 StoreStore Store1; StoreStore; Store2 在store2及其后的写操作执行前，保证store1的写操作已刷新到主内存 LoadStore Load1; LoadStore; Store2 在stroe2及其后的写操作执行前，保证load1的读操作已读取结束 StoreLoad Store1; StoreLoad; Load2 保证store1的写操作已刷新到主内存之后，load2及其后的读操作才能执行

内存屏障，又称内存栅栏，是一个CPU指令，它的作用有两个，

一是保证特定操作的执行顺序，

二是保证某些变量的内存可见性(利用该特性实现volatile的内存可见性)。

由于编译器和处理器都能执行指令重排优化。

如果在指令间插入一条Memory Barrier则会告诉 编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插 入内存屏障禁止在内存屏障前后的指令执行重排序优化。

Memory Barrier的另外一个作用 是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

总之，volatile变量正是通过内存屏障实现其在内存中的语义，即可见性和禁止重排优化。 下面看一个非常典型的禁止重排优化的例子DCL，如下:

来看一个单例模式

public class DoubleCheckLock {
    private static DoubleCheckLock instance;

    private DoubleCheckLock(){}

    private static DoubleCheckLock getInstance() {<br></br>　　　　 // 第一次检查
        if (instance == null) {
            synchronized (DoubleCheckLock.class) {
                <strong>if (instance == null) {<br></br>  　　　　　　　　　　  //多线程环境下可能出问题
                    instance = new</strong><strong> DoubleCheckLock();
                }</strong>
            }
        }
        return instance;
    }
}

上述代码一个经典的单例的双重检测的代码，问题: 为什么要在synchronized里面再次判断instance == null?

因为, 当t1线程抢到锁的时候, 很多其他的线程t2,t3,t4都在外面等着呢, 一旦t1释放锁, 那么t2, t3, t4就立刻抢锁, 那么进来以后, 他们需要知道当前这个对象是否已经被实例化了, 如果还没有被实例化, 那么采取new. 如果已经new过了, 就不在new了

这段代码在单线程环境下并没有什么问题，但如果在多线程环境下就可以出现线程安全问题。

原因在于instance = new DoubleCheckLok(); 这个操作不是原子性的, 它由多个操作构成,如下图:

我们随便new一个对象. 然后看他的字节码文件, 发现一个new操作, 在内存中经过了5步.

首先, 开辟一块内存空间

第二: 入栈

第三: 调用init初始化方法, 也就是构造方法

第四: 弹出,

第五: 返回地址.

主要是第一三五步.

下面来看具体分析:

某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。

因为instance = new DoubleCheckLock();可以分为以下3步完成(伪代码)

<strong>memory = allocate();//1.分配对象内存空间
instance(memory);//2.初始化对象
instance = memory;//3.设置instance指向刚分配的内存地址，此时instance！=null</strong>

由于步骤1和步骤2间可能会重排序，如下:

<strong>memory=allocate();//1.分配对象内存空间
instance=memory;//3.设置instance指向刚分配的内存地址，此时instance！=null，但是对象还没有初始化完成！
instance(memory);//2.初始化对象</strong>

由于步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果 在单线程中并没有改变，因此这种重排优化是允许的。但是指令重排只会保证串行语义的执 行的一致性(单线程)，但并不会关心多线程间的语义一致性。所以当一条线程访问instance 不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。那么该如何 解决呢，很简单，我们使用volatile禁止instance变量被执行指令重排优化即可。

<strong>//禁止指令重排优化
private volatile static DoubleCheckLock instance;</strong>

四 volatile内存语义的实现

前面提到过重排序分为编译器重排序和处理器重排序。为了实现volatile内存语义 ,JMM会分别限制这两种类型的重排序类型

下图是JMM针对编译器制定的volatile重排序规则表。

第一个操作第二个操作：普通读写第二个操作：volatile读第二个操作：volatile写普通读写可以重排 可以重排 不可以重排 volatile读不可以重排 不可以重排 不可以重排 volatile写可以重排 不可以重排 不可以重排

举例来说，第二行最后一个单元格的意思是:

在程序中，当第一个操作为普通变量的读或写 时，如果第二个操作为volatile写，则编译器不能重排序这两个操作。

public voiatile static int a = 1;
public static int b = 2;

public static void main(string[] args) {
　　// 第一个操作是普通读
　　b = 2;

　　// 第二个操作是volatile写
　　a = 3;

　　<strong>// 结论: 这样的两个操作, 不会发生指令重排序</strong>
}

从上图可以看出: cpu定义了, 在使用了volatile以后, 哪种方式会禁止指令重排.

• 当第二个操作是volatile写时，不管第一个操作是什么，都不能重排序。这个规则确保volatile写之前的操作不会被编译器重排序 到volatile写之后。
• 当第一个操作是volatile读时，不管第二个操作是什么，都不 能重排序。这个规则确保volatile读之后的操作不会被编译器重排序到volatile读之前
• 当第一个操作是volatile写，第二个操作是volatile读时，不能重排序

为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。

对于编译器来说，发现一个最优布置来最小化插入屏障的总数几乎不可能。

为此，JMM采取保守策略。下面是基于保守策略的JMM内存屏障插入策略。

• 在每个volatile写操作的前面插入一个StoreStore屏障。
• 在每个volatile写操作的后面插入一个StoreLoad屏障。
• 在每个volatile读操作的后面插入一个LoadLoad屏障。
• 在每个volatile读操作的后面插入一个LoadStore屏障。

上述内存屏障插入策略非常保守，但它可以保证在任意处理器平台，任意的程序中都能得到 正确的volatile内存语义。 下面是保守策略下，volatile写插入内存屏障后生成的指令序列示意图

上图中StoreStore屏障可以保证在volatile写之前，其前面的所有普通写操作已经对任 意处理器可见了。这是因为StoreStore屏障将保障上面所有的普通写在volatile写之前刷新 到主内存。

这里比较有意思的是，volatile写后面的StoreLoad屏障。此屏障的作用是避免volatile 写与 后面可能有的volatile读/写操作重排序。因为编译器常常无法准确判断在一个volatile 写的后面 是否需要插入一个StoreLoad屏障(比如，一个volatile写之后方法立即 return)。为了保证能正确 实现volatile的内存语义，JMM在采取了保守策略:在每个

volatile写的后面，或者在每个volatile 读的前面插入一个StoreLoad屏障。从整体执行效 率的角度考虑，JMM最终选择了在每个 volatile写的后面插入一个StoreLoad屏障。因为 volatile写-读内存语义的常见使用模式是:一个 写线程写volatile变量，多个读线程读同一 个volatile变量。当读线程的数量大大超过写线程时，选择在volatile写之后插入StoreLoad 屏障将带来可观的执行效率的提升。从这里可以看到JMM 在实现上的一个特点:首先确保 正确性，然后再去追求执行效率。

下图是在保守策略下，volatile读插入内存屏障后生成的指令序列示意图

上图中LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序。 LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序。

上述volatile写和volatile读的内存屏障插入策略非常保守。在实际执行时，只要不改变 volatile写-读的内存语义，编译器可以根据具体情况省略不必要的屏障。下面通过具体的示 例
代码进行说明。

针对readAndWrite()方法，编译器在生成字节码时可以做如下的优化。

注意，最后的StoreLoad屏障不能省略。因为第二个volatile写之后，方法立即 return。此时编 译器可能无法准确断定后面是否会有volatile读或写，为了安全起见，编译 器通常会在这里插 入一个StoreLoad屏障。

上面的优化针对任意处理器平台，由于不同的处理器有不同“松紧度”的处理器内存模 型，内存屏障的插入还可以根据具体的处理器内存模型继续优化。以X86处理器为例，图3- 21 中除最后的StoreLoad屏障外，其他的屏障都会被省略。

前面保守策略下的volatile读和写，在X86处理器平台可以优化成如下图所示。前文提 到过，X86处理器仅会对写-读操作做重排序。X86不会对读-读、读-写和写-写操作 做重排 序，因此在X86处理器中会省略掉这3种操作类型对应的内存屏障。在X86中，JMM仅需 在 volatile写后面插入一个StoreLoad屏障即可正确实现volatile写-读的内存语义。

这意味着在 X86处理器中，volatile写的开销比volatile读的开销会大很多（因为执行StoreLoad屏障开销会比较大）。