Happens-Before原则（先行发生原则）

大家好，欢迎来到IT知识分享网。

Happens-Before

从jdk5开始，java使用新的JSR-133内存模型，基于Happens-Before的概念来阐述操作之间的内存可见性。

Happens-Before定义

1. 如果一个操作Happens-Before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。
2. 两个操作之间存在Happens-Before关系，并不意味着一定要按照Happens-Before原则制定的顺序来执行。如果重排序之后的执行结果与按照Happens-Before关系来执行的结果一致，那么这种重排序并不非法。

注意：不能将Happens-Before理解为它的字面意思，可以理解为“先行发生”，如A先行发生于B，就是说B执行之前，A产生的影响（修改共享变量、发送消息、调用方法等）可以被B观察到。（一团浆糊…继续挖）

Happens-Before规则

Happens-Before的八个规则（摘自《深入理解Java虚拟机》12.3.6章节）：

1. 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；
2. 管程锁定规则：一个unLock操作先行发生于后面对同一个锁的lock操作；（此处后面指时间的先后）
3. volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；（此处后面指时间的先后）
4. 线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；
5. 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；
6. 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
7. 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；
8. 传递性：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；

Happens-Before规则详解

程序次序规则

同一个线程内，书写在前面的操作先行发生于书写在后面的操作：在网上有看到过很多文章，但是实际编译时经过指令重排序，有些情况下书写在后面的代码会先于前面的代码。Happens-Before可以理解为前面代码的执行结果对于后面代码是可见的（…怎么说有点绕，看例子吧）。

int a = 3; //代码1 int b = a + 1; //代码2 

上面的代码中，因为代码2的计算会用到代码1的运行结果，此时程序次序规则就会保证代码2中的a一定为3，不会是0(默认初始化的值)，所以JVM不允许操作系统对代码1、2进行重排序，即代码1一定在代码2之前执行。下面的例子就无法保证执行顺序：

int a = 3; //代码1 int b = 2; //代码2 

上面的代码中，代码1、2之间没有依赖关系，所以指令重排序有可能会发生，b的初始化可能比a早。

管程锁定规则

一个unLock操作先行发生于后面对同一个锁的lock操作：同一个锁只能由一个线程持有，下面举例

public class TestHappenBefore { public static int var; private static TestHappenBefore happenBefore = new TestHappenBefore(); public static TestHappenBefore getInstance() { return happenBefore; } public static void main(String[] args) throws InterruptedException { new Thread(() -> TestHappenBefore.getInstance().method2()).start(); new Thread(() -> TestHappenBefore.getInstance().method1()).start(); new Thread(() -> TestHappenBefore.getInstance().method3()).start(); } public synchronized void method1() { var = 3; System.out.println("method1，var：" + var); } public synchronized void method2() { try { System.out.println("线程2开始睡觉了~"); new Thread().sleep(5000); System.out.println("线程2睡好了~"); } catch (InterruptedException e) { e.printStackTrace(); } int b = var; System.out.println("method2，var：" + var + "，b：" + b); } public void method3() { synchronized (new TestHappenBefore()) { //换了把新锁 var = 4; System.out.println("method3，var：" + var); } } } 

执行结果： 线程2开始睡觉了~ method3，var：4 线程2睡好了~ method2，var：4，b：4 method1，var：3 

通过上面的例子我们发现，当线程2在“睡觉”的时间段内，线程1并没有执行，因为此时happenBefore对象的锁被线程2持有，线程2释放锁之前，线程1无法持有该锁，这符合管程锁定规则，还发现线程2“睡觉”的时候，线程3并没有停下，仍然执行了自己的代码，是因为method3的锁和线程2不是同一把锁，所以不受管程锁定规则的限制。

volatile变量规则

对一个变量的写操作先行发生于后面对这个变量的读操作（此处后面指时间的先后）：这条规则保证了volatile变量的可见性，线程A写volatile变量后，线程B读volatile变量，则B读到的一定是A写的值，照旧举例（没有写出合适的案例，附上伪代码说明，如有合适的案例，请指教）：

volatile int a; //线程1执行内容 public void method1() { a = 1; } //线程2执行内容 public void method2() { int b = a; } 

如果线程1先执行，线程2再执行，则volatile变量规则可以保证线程2读取的变量a的值为1。

传递性

如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C（感觉类似数学的传递性：A>B,B>C则A>C…），照旧一例：

volatile int var; int b; int c; //线程1执行内容 public void method1() { b = 4; //1 var = 3; //2 } //线程2执行内容 public void method2() { c = var; //3 c = b; //4 } 

假设执行顺序为 1、2、3、4，由于单线程的程序次序规则，得出1 Happen Before 2，3 Happen Before 4，又因为volatile变量规则得出2 Happen Before 3，所以1 Happen Before 3，1 Happen Before 4（传递性），即最后变量c的值为4；若执行顺序为1、3、4、2，因为3、2没有匹配到Happen Before规则，所以无法通过传递性推测出传递关系，也就无法保证最后变量c的值为4，也可能为0（b初始化的值，没有读到线程1写入的值）

线程启动规则、线程终结规则、线程中断规则、对象终结规则四个规则相对比较易于理解，不再赘述。

Happens-Before原则与时间顺序的关系

前面提到不可以将Happens-Before理解为它的字面意思，即不能站在时间顺序的角度去理解先行发生原则，通过下面的例子来验证一下：

private int value = 0; public void setValue(int value){ this.value = value; } public void getValue(){ return value; } 

// 同一线程内 int i=1; int j=1; 

上面代码运行情况符合程序次序规则，按规则应该是“int i = 1;”的操作先行发生于“int j = 2;”，但“int j = 2;”有可能会先被处理器执行，这并不影响先行发生原则的正确性，因为我们的线程无法感知这点。
通过上面的两个例子，我们得出：时间的先后顺序和先行发生原则（Happen-Before原则）基本没有关系，所以我们在排查线程安全问题的时候不要受到时间顺序的干扰，一切以先行发生原则（Happen-Before原则）为准（摘自《深入理解Java虚拟机》12.3.6章节）。

文章参考：

• 《深入理解Java虚拟机》
• java内存模型-占小狼
• java 8大happen-before原则超全面详解
• 【死磕Java并发】—–Java内存模型之happens-before