多线程（三）重排序与happens-before

1 什么是重排序？

• 计算机在执⾏程序时，为了提⾼性能，编译器和处理器常常会对指令做重排。
• 为什么指令重排序可以提⾼性能？

简单地说，每⼀个指令都会包含多个步骤，每个步骤可能使⽤不同的硬件。因此，流⽔线技术产⽣了，它的原理是指令1还没有执⾏完，就可以开始执⾏指令2，⽽不⽤等到指令1执⾏结束之后再执⾏指令2，这样就⼤⼤提⾼了效率。但是，流⽔线技术最害怕中断，恢复中断的代价是⽐较⼤的，所以我们要想尽办法不让流⽔线中断。指令重排就是减少中断的⼀种技术。我们分析⼀下下⾯这个代码的执⾏情况：
a = b + c;
d = e - f ;
先加载b、c（注意，即有可能先加载b，也有可能先加载c），但是在执⾏add(b,c)的时候，需要等待b、c装载结束才能继续执⾏，也就是增加了停顿，那么后⾯的指令也会依次有停顿,这降低了计算机的执⾏效率。为了减少这个停顿，我们可以先加载e和f,然后再去加载add(b,c),这样做对程序（串⾏）是没有影响的,但却减少了停顿。既然add(b,c)需要停顿，那还不如去做⼀些有意义的事情。

• 综上所述，指令重排对于提⾼CPU处理性能⼗分必要。虽然由此带来了乱序的问题，但是这点牺牲是值得的。
• 指令重排⼀般分为以下三种：

1. 编译器优化重排
   编译器在不改变单线程程序语义的前提下，可以重新安排语句的执⾏顺序。
2. 指令并⾏重排
   现代处理器采⽤了指令级并⾏技术来将多条指令重叠执⾏。如果不存在数据依赖性(即后⼀个执⾏的语句⽆需依赖前⾯执⾏的语句的结果)，处理器可以改变语句对应的机器指令的执⾏顺序。
3. 内存系统重排
   由于处理器使⽤缓存和读写缓存冲区，这使得加载(load)和存储(store)操作看上去可能是在乱序执⾏，因为三级缓存的存在，导致内存与缓存的数据同步存在时间差。

指令重排可以保证串⾏语义⼀致，但是没有义务保证多线程间的语义也⼀致。所以在多线程下，指令重排序可能会导致⼀些问题。

2 顺序⼀致性模型与JMM的保证

顺序⼀致性模型是⼀个理论参考模型，内存模型在设计的时候都会以顺序⼀致性内存模型作为参考。

2.1 数据竞争与顺序⼀致性

• 当程序未正确同步的时候，就可能存在数据竞争。

• 数据竞争：在⼀个线程中写⼀个变量，在另⼀个线程读同⼀个变量，并且写和读没有通过同步来排序。

• 如果程序中包含了数据竞争，那么运⾏的结果往往充满了不确定性，⽐如读发⽣在了写之前，可能就会读到错误的值；如果⼀个线程程序能够正确同步，那么就不存在数据竞争。
• Java内存模型（JMM）对于正确同步多线程程序的内存⼀致性做了以下保证：

• 如果程序是正确同步的，程序的执⾏将具有顺序⼀致性。 即程序的执⾏结果和该程序在顺序⼀致性模型中执⾏的结果相同。
• 这⾥的同步包括了使⽤ volatile 、 final 、 synchronized 等关键字来实现多线程下的同步。
• 如果程序员没有正确使⽤ volatile 、 final 、 synchronized ，那么即便是使⽤了同步（单线程下的同步），JMM也不会有内存可⻅性的保证，可能会导致你的程序出错，并且具有不可重现性，很难排查。

2.2 顺序⼀致性模型

• 顺序⼀致性内存模型是⼀个理想化的理论参考模型，它为程序员提供了极强的内存可⻅性保证。
• 顺序⼀致性模型有两⼤特性：

• ⼀个线程中的所有操作必须按照程序的顺序（即Java代码的顺序）来执⾏。
• 不管程序是否同步，所有线程都只能看到⼀个单⼀的操作执⾏顺序。即在顺序⼀致性模型中，每个操作必须是原⼦性的，且⽴刻对所有线程可⻅。

• 为了理解这两个特性，我们举个例⼦，假设有两个线程A和B并发执⾏，线程A有3个操作，他们在程序中的顺序是A1->A2->A3，线程B也有3个操作，B1->B2->B3。
• 假设正确使⽤了同步，A线程的3个操作执⾏后释放锁，B线程获取同⼀个锁。那么在顺序⼀致性模型中的执⾏效果如下所示：

• 操作的执⾏整体上有序，并且两个线程都只能看到这个执⾏顺序。
• 假设没有使⽤同步，那么在顺序⼀致性模型中的执⾏效果如下所示：

• 操作的执⾏整体上⽆序，但是两个线程都只能看到这个执⾏顺序。之所以可以得到这个保证，是因为顺序⼀致性模型中的每个操作必须⽴即对任意线程可⻅。

但是JMM没有这样的保证。

• ⽐如，在当前线程把写过的数据缓存在本地内存中，在没有刷新到主内存之前，这个写操作仅对当前线程可⻅；从其他线程的⻆度来观察，这个写操作根本没有被当前线程所执⾏。只有当前线程把本地内存中写过的数据刷新到主内存之后，这个写操作才对其他线程可⻅。在这种情况下，当前线程和其他线程看到的执⾏顺序是不⼀样的。

2.3 JMM中同步程序的顺序⼀致性效果

• 在顺序⼀致性模型中，所有操作完全按照程序的顺序串⾏执⾏。但是JMM中，临界区内（同步块或同步⽅法中）的代码可以发⽣重排序（但不允许临界区内的代码“逃逸”到临界区之外，因为会破坏锁的内存语义）。

• 虽然线程A在临界区做了重排序，但是因为锁的特性，线程B⽆法观察到线程A在临界区的重排序。这种重排序既提⾼了执⾏效率，⼜没有改变程序的执⾏结果。

• 同时，JMM会在退出临界区和进⼊临界区做特殊的处理，使得在临界区内程序获得与顺序⼀致性模型相同的内存视图。
  由此可⻅，JMM的具体实现⽅针是：在不改变（正确同步的）程序执⾏结果的前提下，尽量为编译期和处理器的优化打开⽅便之⻔。

2.4 JMM中未同步程序的顺序⼀致性效果

• 对于未同步的多线程程序，JMM只提供最⼩安全性：线程读取到的值，要么是之前某个线程写⼊的值，要么是默认值，不会⽆中⽣有。

• 为了实现这个安全性，JVM在堆上分配对象时，⾸先会对内存空间清零，然后才会在上⾯分配对象（这两个操作是同步的）。

• JMM没有保证未同步程序的执⾏结果与该程序在顺序⼀致性中执⾏结果⼀致。因为如果要保证执⾏结果⼀致，那么JMM需要禁⽌⼤量的优化，对程序的执⾏性能会产⽣很⼤的影响。

• 未同步程序在JMM和顺序⼀致性内存模型中的执⾏特性有如下差异：

1. 顺序⼀致性保证单线程内的操作会按程序的顺序执⾏；JMM不保证单线程内的操作会按程序的顺序执⾏。（因为重排序，但是JMM保证单线程下的重排序不影响执⾏结果）
2. 顺序⼀致性模型保证所有线程只能看到⼀致的操作执⾏顺序，⽽JMM不保证所有线程能看到⼀致的操作执⾏顺序。（因为JMM不保证所有操作⽴即可⻅）
3. JMM不保证对64位的long型和double型变量的写操作具有原⼦性，⽽顺序⼀致性模型保证对所有的内存读写操作都具有原⼦性。

3 happens-before

3.1 什么是happens-before?

• ⼀⽅⾯，程序员需要JMM提供⼀个强的内存模型来编写代码；另⼀⽅⾯，编译器和处理器希望JMM对它们的束缚越少越好，这样它们就可以最可能多的做优化来提⾼性能，希望的是⼀个弱的内存模型。

• JMM考虑了这两种需求，并且找到了平衡点，对编译器和处理器来说，只要不改变程序的执⾏结果（单线程程序和正确同步了的多线程程序），编译器和处理器怎么优化都⾏。

• ⽽对于程序员，JMM提供了happens-before规则（JSR-133规范），满⾜了程序员的需求——简单易懂，并且提供了⾜够强的内存可⻅性保证。换⾔之，程序员只要遵循happens-before规则，那他写的程序就能保证在JMM中具有强的内存可⻅性。

• JMM使⽤happens-before的概念来定制两个操作之间的执⾏顺序。这两个操作可以在⼀个线程以内，也可以是不同的线程之间。因此，JMM可以通过happens-before关系向程序员提供跨线程的内存可⻅性保证。

• happens-before关系的定义如下：

1. 如果⼀个操作happens-before另⼀个操作，那么第⼀个操作的执⾏结果将对第⼆个操作可⻅，⽽且第⼀个操作的执⾏顺序排在第⼆个操作之前。
2. 两个操作之间存在happens-before关系，并不意味着Java平台的具体实现必须要按照happens-before关系指定的顺序来执⾏。如果重排序之后的执⾏结果，与按happens-before关系来执⾏的结果⼀致，那么JMM也允许这样的重排序。

• happens-before关系本质上和as-if-serial语义是⼀回事。
• as-if-serial语义保证单线程内重排序后的执⾏结果和程序代码本身应有的结果是⼀致的，happens-before关系保证正确同步的多线程程序的执⾏结果不被重排序改变。
• 总之，如果操作A happens-before操作B，那么操作A在内存上所做的操作对操作B都是可⻅的，不管它们在不在⼀个线程。

3.2 天然的happens-before关系

在Java中，有以下天然的happens-before关系：

• 程序顺序规则：⼀个线程中的每⼀个操作，happens-before于该线程中的任意后续操作。
• 监视器锁规则：对⼀个锁的解锁，happens-before于随后对这个锁的加锁。
• volatile变量规则：对⼀个volatile域的写，happens-before于任意后续对这个volatile域的读。
• 传递性：如果A happens-before B，且B happens-before C，那么A happensbeforeC。
• start规则：如果线程A执⾏操作ThreadB.start()启动线程B，那么A线程的ThreadB.start()操作happens-before于线程B中的任意操作、
• join规则：如果线程A执⾏操作ThreadB.join()并成功返回，那么线程B中的任意操作happens-before于线程A从ThreadB.join()操作成功返回。

重排序有两类，JMM对这两类重排序有不同的策略：

1. 会改变程序执⾏结果的重排序，JMM要求编译器和处理器都禁⽌这种重排序。
2. 不会改变程序执⾏结果的重排序，JMM对编译器和处理器不做要求，允许这种重排序。