深入理解JAVA内存模型第一部分

柔情只为你懂 2022-08-08 05:13 197阅读 0赞

并发编程模型的分类

在并发编程中，我们需要处理两个关键问题：线程之间如何通信以及线程之间如何同步(这里的线程是指并发执行的活动实体)。通信是指线程之间以何种机制来交换信息。在命令式编程中，线程之间的通信机制有两种：共享内存和消息传递。

在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐士进行通信。在消息传递的并发模型里，线程之间没有公共状态，线程之间必须通过明确的发送消息来显示进行通信。

同步是指程序用于控制不同线程之间操作发生相对顺序的机制。在共享内存并发模型里，同步是显示进行的。程序猿必须显示指定某个方法或某段代码需在线程之间互斥执行。在消息传递的并发模型里，由于消息的发送必须在消息的接收之前，因此同步是隐式进行的。

Java内存模型的抽象

Java的并发采用的是共享内存模型，Java线程之间的通信总是隐式进行。整个通信过程对程序员完全透明。如果编写多线程程序的java程序员不理解隐式进行的线程之间通信的工作机制，可能会遇到各种奇怪的内存可见性问题。

在java中，所有的实例域，静态域和数组元素存储在堆内存中，堆内存在线程之间共享(本文用共享变量代指实例域，静态域和数组元素)。局部变量(Local variables)，方法定义参数和异常处理器参数不会在线程之间共享。他们不会有内存可见性问题。

Java线程之间的通信由Java内存模型（本文简称为JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。Java内存模型的抽象示意图如下：

![11.png][]

从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：

1.  首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
2.  然后，线程B到主内存中去读取线程A之前已更新过的共享变量。

下面通过示意图来说明这两个步骤：

![22.png][]

如上图所示，本地内存A和B有主内存中共享变量x的副本。假设初始时，这三个内存中的x值都为0。线程A在执行时，把更新后的x值（假设值为1）临时存放在自己的本地内存A中。当线程A和线程B需要通信时，线程A首先会把自己本地内存中修改后的x值刷新到主内存中，此时主内存中的x值变为了1。随后，线程B到主内存中去读取线程A更新后的x值，此时线程B的本地内存的x值也变为了1。

从整体来看，这两个步骤实质上是线程A在向线程B发送消息，而且这个通信过程必须要经过主内存。JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证。

重排序

在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。重排序分三种类型：

1.  编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
2.  指令级并行的重排序。现代处理器采用了指令级并行技术（Instruction-Level Parallelism， ILP）来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
3.  内存系统的重排序。由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

从java源代码到最终实际执行的指令序列，会分别经历下面三种重排序：

![33.png][]

上述的1属于编译器重排序，2和3属于处理器重排序。这些重排序都可能会导致多线程程序出现内存可见性问题。对于编译器，JMM的编译器重排序规则会禁止特定类型的编译器重排序（不是所有的编译器重排序都要禁止）。对于处理器重排序，JMM的处理器重排序规则会要求java编译器在生成指令序列时，插入特定类型的内存屏障（memory barriers，intel称之为memory fence）指令，通过内存屏障指令来禁止特定类型的处理器重排序（不是所有的处理器重排序都要禁止）。

JMM属于语言级的内存模型，它确保在不同的编译器和不同的处理器平台之上，通过禁止特定类型的编译器重排序和处理器重排序，为程序员提供一致的内存可见性保证。

## 处理器重排序与内存屏障指令 ##

现代的处理器使用写缓冲区来临时保存向内存写入的数据。写缓冲区可以保证指令流水线持续运行，它可以避免由于处理器停顿下来等待向内存写入数据而产生的延迟。同时，通过以批处理的方式刷新写缓冲区，以及合并写缓冲区中对同一内存地址的多次写，可以减少对内存总线的占用。虽然写缓冲区有这么多好处，但每个处理器上的写缓冲区，仅仅对它所在的处理器可见。这个特性会对内存操作的执行顺序产生重要的影响：处理器对内存的读/写操作的执行顺序，不一定与内存实际发生的读/写操作顺序一致！为了具体说明，请看下面示例：

假设处理器A和处理器B按程序的顺序并行执行内存访问，最终却可能得到x = y = 0的结果。具体的原因如下图所示：

![44.png][]

这里处理器A和处理器B可以同时把共享变量写入自己的写缓冲区（A1，B1），然后从内存中读取另一个共享变量（A2，B2），最后才把自己写缓存区中保存的脏数据刷新到内存中（A3，B3）。当以这种时序执行时，程序就可以得到x = y = 0的结果。

从内存操作实际发生的顺序来看，直到处理器A执行A3来刷新自己的写缓存区，写操作A1才算真正执行了。虽然处理器A执行内存操作的顺序为：A1->A2，但内存操作实际发生的顺序却是：A2->A1。此时，处理器A的内存操作顺序被重排序了（处理器B的情况和处理器A一样，这里就不赘述了）。

这里的关键是，由于写缓冲区仅对自己的处理器可见，它会导致处理器执行内存操作的顺序可能会与内存实际的操作执行顺序不一致。由于现代的处理器都会使用写缓冲区，因此现代的处理器都会允许对写-读操做重排序。

下面是常见处理器允许的重排序类型的列表：

<table style="border-collapse:collapse; border-spacing:0px; margin:10px 0px; border:1px solid rgb(224,224,224); padding:0px; color:rgb(0,0,0); font-family:Arial,sans-serif; font-size:14px; line-height:21px"> 
 <tbody style="margin:0px; border:0px; padding:0px"> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">&nbsp;</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Load-Load</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Load-Store</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Store-Store</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Store-Load</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">数据依赖</td> 
  </tr> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">sparc-TSO</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
  </tr> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">x86</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
  </tr> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">ia64</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
  </tr> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">PowerPC</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Y</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">N</td> 
  </tr> 
 </tbody> 
</table>

上表单元格中的“N”表示处理器不允许两个操作重排序，“Y”表示允许重排序。

从上表我们可以看出：常见的处理器都允许Store-Load重排序；常见的处理器都不允许对存在数据依赖的操作做重排序。sparc-TSO和x86拥有相对较强的处理器内存模型，它们仅允许对写-读操作做重排序（因为它们都使用了写缓冲区）。

※注1：sparc-TSO是指以TSO(Total Store Order)内存模型运行时，sparc处理器的特性。

※注2：上表中的x86包括x64及AMD64。

※注3：由于ARM处理器的内存模型与PowerPC处理器的内存模型非常类似，本文将忽略它。

※注4：数据依赖性后文会专门说明。

为了保证内存可见性，java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。JMM把内存屏障指令分为下列四类：

<table style="border-collapse:collapse; border-spacing:0px; margin:10px 0px; border:1px solid rgb(224,224,224); padding:0px; color:rgb(0,0,0); font-family:Arial,sans-serif; font-size:14px; line-height:21px"> 
 <tbody style="margin:0px; border:0px; padding:0px"> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">屏障类型</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">指令示例</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">说明</td> 
  </tr> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">LoadLoad Barriers</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Load1; LoadLoad; Load2</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">确保Load1数据的装载，之前于Load2及所有后续装载指令的装载。</td> 
  </tr> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">StoreStore Barriers</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Store1; StoreStore; Store2</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">确保Store1数据对其他处理器可见（刷新到内存），之前于Store2及所有后续存储指令的存储。</td> 
  </tr> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">LoadStore Barriers</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Load1; LoadStore; Store2</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">确保Load1数据装载，之前于Store2及所有后续的存储指令刷新到内存。</td> 
  </tr> 
  <tr style="margin:0px; border:0px; padding:0px"> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">StoreLoad Barriers</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">Store1; StoreLoad; Load2</td> 
   <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)">确保Store1数据对其他处理器变得可见（指刷新到内存），之前于Load2及所有后续装载指令的装载。StoreLoad Barriers会使该屏障之前的所有内存访问指令（存储和装载指令）完成之后，才执行该屏障之后的内存访问指令。</td> 
  </tr> 
 </tbody> 
</table>

StoreLoad Barriers是一个“全能型”的屏障，它同时具有其他三个屏障的效果。现代的多处理器大都支持该屏障（其他类型的屏障不一定被所有处理器支持）。执行该屏障开销会很昂贵，因为当前处理器通常要把写缓冲区中的数据全部刷新到内存中（buffer fully flush）。

## happens-before ##

从JDK5开始，java使用新的JSR -133内存模型（本文除非特别说明，针对的都是JSR- 133内存模型）。JSR-133提出了happens-before的概念，通过这个概念来阐述操作之间的内存可见性。如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。这里提到的两个操作既可以是在一个线程之内，也可以是在不同线程之间。 与程序员密切相关的happens-before规则如下：

*  程序顺序规则：一个线程中的每个操作，happens- before 于该线程中的任意后续操作。
 *  监视器锁规则：对一个监视器锁的解锁，happens- before 于随后对这个监视器锁的加锁。
 *  volatile变量规则：对一个volatile域的写，happens- before 于任意后续对这个volatile域的读。
 *  传递性：如果A happens- before B，且B happens- before C，那么A happens- before C。

注意，两个操作之间具有happens-before关系，并不意味着前一个操作必须要在后一个操作之前执行！happens-before仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前（the first is visible to and ordered before the second）。happens- before的定义很微妙，后文会具体说明happens-before为什么要这么定义。

happens-before与JMM的关系如下图所示：

![55.png][]

如上图所示，一个happens-before规则通常对应于多个编译器重排序规则和处理器重排序规则。对于java程序员来说，happens-before规则简单易懂，它避免程序员为了理解JMM提供的内存可见性保证而去学习复杂的重排序规则以及这些规则的具体实现。

## 数据依赖性 ##

如果两个操作访问同一个变量，且这两个操作中有一个为写操作，此时这两个操作之间就存在数据依赖性。数据依赖分下列三种类型：

上面三种情况，只要重排序两个操作的执行顺序，程序的执行结果将会被改变。

前面提到过，编译器和处理器可能会对操作做重排序。编译器和处理器在重排序时，会遵守数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。

as-if-serial语义注意，这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操作，不同处理器之间和不同线程之间的数据依赖性不被编译器和处理器考虑。

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

为了遵守as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操作做重排序，因为这种重排序会改变执行结果。但是，如果操作之间不存在数据依赖关系，这些操作可能被编译器和处理器重排序。为了具体说明，请看下面计算圆面积的代码示例：

double pi  = 3.14;    //A
    double r   = 1.0;     //B
    double area = pi * r * r; //C

上面三个操作的数据依赖关系如下图所示：

![11.png 1][]

如上图所示，A和C之间存在数据依赖关系，同时B和C之间也存在数据依赖关系。因此在最终执行的指令序列中，C不能被重排序到A和B的前面（C排到A和B的前面，程序的结果将会被改变）。但A和B之间没有数据依赖关系，编译器和处理器可以重排序A和B之间的执行顺序。下图是该程序的两种执行顺序：

![22.png 1][]

as-if-serial语义把单线程程序保护了起来，遵守as-if-serial语义的编译器，runtime 和处理器共同为编写单线程程序的程序员创建了一个幻觉：单线程程序是按程序的顺序来执行的。as-if-serial语义使单线程程序员无需担心重排序会干扰他们，也无需担心内存可见性问题。

## 程序顺序规则 ##

根据happens- before的程序顺序规则，上面计算圆的面积的示例代码存在三个happens- before关系：

1.  A happens- before B；
2.  B happens- before C；
3.  A happens- before C；

这里的第3个happens- before关系，是根据happens- before的传递性推导出来的。

这里A happens- before B，但实际执行时B却可以排在A之前执行（看上面的重排序后的执行顺序）。在第一章提到过，如果A happens- before B，JMM并不要求A一定要在B之前执行。JMM仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前。这里操作A的执行结果不需要对操作B可见；而且重排序操作A和操作B后的执行结果，与操作A和操作B按happens- before顺序执行的结果一致。在这种情况下，JMM会认为这种重排序并不非法（not illegal），JMM允许这种重排序。

在计算机中，软件技术和硬件技术有一个共同的目标：在不改变程序执行结果的前提下，尽可能的开发并行度。编译器和处理器遵从这一目标，从happens- before的定义我们可以看出，JMM同样遵从这一目标。

## 重排序对多线程的影响 ##

现在让我们来看看，重排序是否会改变多线程程序的执行结果。请看下面的示例代码：

class ReorderExample {
    int a = 0;
    boolean flag = false;
    
    public void writer() {
        a = 1;                   //1
        flag = true;             //2
    }
    
    Public void reader() {
        if (flag) {                //3
            int i =  a * a;        //4
            ……
        }
    }
    }

flag变量是个标记，用来标识变量a是否已被写入。这里假设有两个线程A和B，A首先执行writer()方法，随后B线程接着执行reader()方法。线程B在执行操作4时，能否看到线程A在操作1对共享变量a的写入？

答案是：不一定能看到。

由于操作1和操作2没有数据依赖关系，编译器和处理器可以对这两个操作重排序；同样，操作3和操作4没有数据依赖关系，编译器和处理器也可以对这两个操作重排序。让我们先来看看，当操作1和操作2重排序时，可能会产生什么效果？请看下面的程序执行时序图：

![33.png 1][]

如上图所示，操作1和操作2做了重排序。程序执行时，线程A首先写标记变量flag，随后线程B读这个变量。由于条件判断为真，线程B将读取变量a。此时，变量a还根本没有被线程A写入，在这里多线程程序的语义被重排序破坏了！

※注：本文统一用红色的虚箭线表示错误的读操作，用绿色的虚箭线表示正确的读操作。

下面再让我们看看，当操作3和操作4重排序时会产生什么效果（借助这个重排序，可以顺便说明控制依赖性）。下面是操作3和操作4重排序后，程序的执行时序图：

![44.png 1][]

在程序中，操作3和操作4存在控制依赖关系。当代码中存在控制依赖性时，会影响指令序列执行的并行度。为此，编译器和处理器会采用猜测（Speculation）执行来克服控制相关性对并行度的影响。以处理器的猜测执行为例，执行线程B的处理器可以提前读取并计算a\*a，然后把计算结果临时保存到一个名为重排序缓冲（reorder buffer ROB）的硬件缓存中。当接下来操作3的条件判断为真时，就把该计算结果写入变量i中。

从图中我们可以看出，猜测执行实质上对操作3和4做了重排序。重排序在这里破坏了多线程程序的语义！

在单线程程序中，对存在控制依赖的操作重排序，不会改变执行结果（这也是as-if-serial语义允许对存在控制依赖的操作做重排序的原因）；但在多线程程序中，对存在控制依赖的操作重排序，可能会改变程序的执行结果。

[11.png]: http://infoqstatic.com/resource/articles/java-memory-model-1/zh/resources/11.png
[22.png]: http://infoqstatic.com/resource/articles/java-memory-model-1/zh/resources/22.png
[33.png]: http://infoqstatic.com/resource/articles/java-memory-model-1/zh/resources/33.png
[44.png]: http://infoqstatic.com/resource/articles/java-memory-model-1/zh/resources/44.png
[55.png]: http://infoqstatic.com/resource/articles/java-memory-model-1/zh/resources/55.png
[11.png 1]: http://infoqstatic.com/resource/articles/java-memory-model-2/zh/resources/11.png
[22.png 1]: http://infoqstatic.com/resource/articles/java-memory-model-2/zh/resources/22.png
[33.png 1]: http://infoqstatic.com/resource/articles/java-memory-model-2/zh/resources/33.png
[44.png 1]: http://infoqstatic.com/resource/articles/java-memory-model-2/zh/resources/44.png