来一波关于Java内存模型的详解

超、凢脫俗 2024-03-26 12:28 62阅读 0赞

## 什么是JMM ##

![95d03be5744b4aa48a4f2499b64e8e24.png][]

### 并发编程领域的关键问题 ###

#### 线程之间的通信 ####

线程的通信是指线程之间以何种机制来交换信息。在编程中，线程之间的通信机制有两种，共享内存和消息传递。 在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信，典型的共享内存通信方式就是通过共享对象进行通信。 在消息传递的并发模型里，线程之间没有公共状态，线程之间必须通过明确的发送消息来显式进行通信，在java中典型的消息传递方式就是wait()和notify()。

#### 线程间的同步 ####

> 同步是指程序用于控制不同线程之间操作发生相对顺序的机制。

在共享内存并发模型里，同步是显式进行的。程序员必须显式指定某个方法或某段代码需要在线程之间互斥执行。 在消息传递的并发模型里，由于消息的发送必须在消息的接收之前，因此同步是隐式进行的。

#### 现代计算机的内存模型 ####

物理计算机中的并发问题，物理机遇到的并发问题与虚拟机中的情况有不少相似之处，物理机对并发的处理方案对于虚拟机的实现也有相当大的参考意义。

其中一个重要的复杂性来源是绝大多数的运算任务都不可能只靠处理器“计算”就能完成，处理器至少要与内存交互，如读取运算数据、存储运算结果等，这个I/O操作是很难消除的（无法仅靠寄存器来完成所有运算任务）。

早期计算机中cpu和内存的速度是差不多的，但在现代计算机中，cpu的指令速度远超内存的存取速度,由于计算机的存储设备与处理器的运算速度有几个数量级的差距，所以现代计算机系统都不得不加入一层读写速度尽可能接近处理器运算速度的高速缓存（Cache）来作为内存与处理器之间的缓冲：将运算需要使用到的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存同步回内存之中，这样处理器就无须等待缓慢的内存读写了。

基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，但是也为计算机系统带来更高的复杂度，因为它引入了一个新的问题：缓存一致性（Cache Coherence）。

在多处理器系统中，每个处理器都有自己的高速缓存，而它们又共享同一主内存（MainMemory）。当多个处理器的运算任务都涉及同一块主内存区域时，将可能导致各自的缓存数据不一致，举例说明变量在多个CPU之间的共享。

如果真的发生这种情况，那同步回到主内存时以谁的缓存数据为准呢？为了解决一致性的问题，需要各个处理器访问缓存时都遵循一些协议，在读写时要根据协议来进行操作，这类协议有MSI、MESI（Illinois Protocol）、MOSI、Synapse、Firefly及Dragon Protocol等。

![c06b8de1a13d49d7b9121a1e36afb7a8.png][]

#### 该内存模型带来的问题 ####

现代的处理器使用写缓冲区临时保存向内存写入的数据。写缓冲区可以保证指令流水线持续运行，它可以避免由于处理器停顿下来等待向内存写入数据而产生的延迟。

同时，通过以批处理的方式刷新写缓冲区，以及合并写缓冲区中对同一内存地址的多次写，减少对内存总线的占用。

虽然写缓冲区有这么多好处，但每个处理器上的写缓冲区，仅仅对它所在的处理器可见。这个特性会对内存操作的执行顺序产生重要的影响：处理器对内存的读/写操作的执行顺序，不一定与内存实际发生的读/写操作顺序一致！ 处理器A和处理器B按程序的顺序并行执行内存访问，最终可能得到x=y=0的结果。 处理器A和处理器B可以同时把共享变量写入自己的写缓冲区（A1，B1），然后从内存中读取另一个共享变量（A2，B2），最后才把自己写缓存区中保存的脏数据刷新到内存中（A3，B3）。

当以这种时序执行时，程序就可以得到x=y=0的结果。 从内存操作实际发生的顺序来看，直到处理器A执行A3来刷新自己的写缓存区，写操作A1才算真正执行了。虽然处理器A执行内存操作的顺序为：A1→A2，但内存操作实际发生的顺序却是A2→A1。

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>Processor A</th> 
   <th>Processor B</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>代码</td> 
   <td>a=1; //A1 x=1; //A2</td> 
   <td>b=2; //B1 y=a; //B2</td> 
  </tr> 
  <tr> 
   <td>运行结果</td> 
   <td>初始状态 a=b=0 处理器允许得到结果 x=y=0</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

![8f6bb11303e341e6ad1504f69f9a0c51.png][]

#### Java内存模型定义 ####

JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。

从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。

本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。

![f549d41a61624f8d838a74b29cc815bc.png][]

#### Java内存区域 ####

![bc47759625bb41e7a79b5ff8334a858b.png][]

> Java虚拟机在运行程序时会把其自动管理的内存划分为以上几个区域，每个区域都有的用途以及创建销毁的时机，其中蓝色部分代表的是所有线程共享的数据区域，而紫色部分代表的是每个线程的私有数据区域。

#### 方法区 ####

方法区属于线程共享的内存区域，又称Non-Heap（非堆），主要用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据，根据Java 虚拟机规范的规定，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError 异常。

值得注意的是在方法区中存在一个叫运行时常量池(Runtime Constant Pool）的区域，它主要用于存放编译器生成的各种字面量和符号引用，这些内容将在类加载后存放到运行时常量池中，以便后续使用。

#### JVM堆 ####

Java 堆也是属于线程共享的内存区域，它在虚拟机启动时创建，是Java 虚拟机所管理的内存中最大的一块，主要用于存放对象实例，几乎所有的对象实例都在这里分配内存，注意Java 堆是垃圾收集器管理的主要区域，因此很多时候也被称做GC 堆，如果在堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError 异常。

#### 程序计数器 ####

属于线程私有的数据区域，是一小块内存空间，主要代表当前线程所执行的字节码行号指示器。字节码解释器工作时，通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

#### 虚拟机栈 ####

属于线程私有的数据区域，与线程同时创建，总数与线程关联，代表Java方法执行的内存模型。每个方法执行时都会创建一个栈桢来存储方法的的变量表、操作数栈、动态链接方法、返回值、返回地址等信息。每个方法从调用直结束就对于一个栈桢在虚拟机栈中的入栈和出栈过程，如下（图有误，应该为栈桢）：

#### 本地方法栈 ####

本地方法栈属于线程私有的数据区域，这部分主要与虚拟机用到的 Native 方法相关，一般情况下，我们无需关心此区域。

#### 小结 ####

这里之所以简要说明这部分内容，注意是为了区别Java内存模型与Java内存区域的划分，毕竟这两种划分是属于不同层次的概念。

#### Java内存模型概述 ####

Java内存模型(即Java Memory Model，简称JMM)本身是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间)，用于存储线程私有的数据，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，

所有线程都可以访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行，首先要将变量从主内存拷贝的自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，工作内存中存储着主内存中的变量副本拷贝，

前面说过，工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成，其简要访问过程如下图

![edb8e8486ac7455ba0524c8fed11ea3e.png][]

需要注意的是，JMM与Java内存区域的划分是不同的概念层次，更恰当说JMM描述的是一组规则，通过这组规则控制程序中各个变量在共享数据区域和私有数据区域的访问方式，JMM是围绕原子性，有序性、可见性展开的(稍后会分析)。

JMM与Java内存区域唯一相似点，都存在共享数据区域和私有数据区域，在JMM中主内存属于共享数据区域，从某个程度上讲应该包括了堆和方法区，而工作内存数据线程私有数据区域，从某个程度上讲则应该包括程序计数器、虚拟机栈以及本地方法栈。

或许在某些地方，我们可能会看见主内存被描述为堆内存，工作内存被称为线程栈，实际上他们表达的都是同一个含义。关于JMM中的主内存和工作内存说明如下

#### 主内存 ####

主要存储的是Java实例对象，所有线程创建的实例对象都存放在主内存中，不管该**实例对象是成员变量还是方法中的本地变量(也称局部变量)**，当然也包括了共享的类信息、常量、静态变量。

由于是共享数据区域，多条线程对同一个变量进行访问可能会发现线程安全问题。

#### 工作内存 ####

主要存储当前方法的所有本地变量信息(工作内存中存储着主内存中的变量副本拷贝)，每个线程只能访问自己的工作内存，即线程中的本地变量对其它线程是不可见的，就算是两个线程执行的是同一段代码，它们也会各自在自己的工作内存中创建属于当前线程的本地变量，当然也包括了字节码行号指示器、相关Native方法的信息。

注意由于工作内存是每个线程的私有数据，线程间无法相互访问工作内存，因此存储在工作内存的数据不存在线程安全问题。

#### 数据同步 ####

弄清楚主内存和工作内存后，接了解一下主内存与工作内存的数据存储类型以及操作方式，根据虚拟机规范，对于一个实例对象中的成员方法而言，如果方法中包含本地变量是基本数据类型（boolean，byte，short，char，int，long，float，double），将直接存储在工作内存的帧栈结构中，但倘若本地变量是引用类型，那么该变量的引用会存储在功能内存的帧栈中，而对象实例将存储在主内存(共享数据区域，堆)中。

但对于实例对象的成员变量，不管它是基本数据类型或者包装类型(Integer、Double等)还是引用类型，都会被存储到堆区。

至于static变量以及类本身相关信息将会存储在主内存中。需要注意的是，在主内存中的实例对象可以被多线程共享，倘若两个线程同时调用了同一个对象的同一个方法，那么两条线程会将要操作的数据拷贝一份到自己的工作内存中，执行完成操作后才刷新到主内存，简单示意图如下所示：

![bcf21459423a48d387c86e635f0f2a04.png][]

#### 硬件内存架构与Java内存模型 ####

#### 硬件内存架构 ####

![dfc99c86d1524053b3e22b0b0d8ff6e1.png][]

正如上图所示，经过简化CPU与内存操作的简易图，实际上没有这么简单，这里为了理解方便，我们省去了南北桥并将三级缓存统一为CPU缓存(有些CPU只有二级缓存，有些CPU有三级缓存)。

就目前计算机而言，一般拥有多个CPU并且每个CPU可能存在多个核心，多核是指在一枚处理器(CPU)中集成两个或多个完整的计算引擎(内核),这样就可以支持多任务并行执行，从多线程的调度来说，每个线程都会映射到各个CPU核心中并行运行。

在CPU内部有一组CPU寄存器，寄存器是cpu直接访问和处理的数据，是一个临时放数据的空间。一般CPU都会从内存取数据到寄存器，然后进行处理，但由于内存的处理速度远远低于CPU，导致CPU在处理指令时往往花费很多时间在等待内存做准备工作

于是在寄存器和主内存间添加了CPU缓存，CPU缓存比较小，但访问速度比主内存快得多，如果CPU总是操作主内存中的同一址地的数据，很容易影响CPU执行速度，此时CPU缓存就可以把从内存提取的数据暂时保存起来，如果寄存器要取内存中同一位置的数据，直接从缓存中提取，无需直接从主内存取。

需要注意的是，寄存器并不每次数据都可以从缓存中取得数据，万一不是同一个内存地址中的数据，那寄存器还必须直接绕过缓存从内存中取数据。

所以并不每次都得到缓存中取数据，这种现象有个专业的名称叫做缓存的命中率，从缓存中取就命中，不从缓存中取从内存中取，就没命中，可见缓存命中率的高低也会影响CPU执行性能，这就是CPU、缓存以及主内存间的简要交互过程，

总而言之当一个CPU需要访问主存时，会先读取一部分主存数据到CPU缓存(当然如果CPU缓存中存在需要的数据就会直接从缓存获取)，进而在读取CPU缓存到寄存器，当CPU需要写数据到主存时，同样会先刷新寄存器中的数据到CPU缓存，然后再把数据刷新到主内存中。

#### Java线程与硬件处理器 ####

了解完硬件的内存架构后，接着了解JVM中线程的实现原理，理解线程的实现原理，有助于我们了解Java内存模型与硬件内存架构的关系，在Window系统和Linux系统上，Java线程的实现是基于一对一的线程模型，所谓的一对一模型，实际上就是通过语言级别层面程序去间接调用系统内核的线程模型，即我们在使用Java线程时，Java虚拟机内部是转而调用当前操作系统的内核线程来完成当前任务。

这里需要了解一个术语，内核线程(Kernel-Level Thread，KLT)，它是由操作系统内核(Kernel)支持的线程，这种线程是由操作系统内核来完成线程切换，内核通过操作调度器进而对线程执行调度，并将线程的任务映射到各个处理器上。每个内核线程可以视为内核的一个分身,这也就是操作系统可以同时处理多任务的原因。

由于我们编写的多线程程序属于语言层面的，程序一般不会直接去调用内核线程，取而代之的是一种轻量级的进程(Light Weight Process)，也是通常意义上的线程，由于每个轻量级进程都会映射到一个内核线程，因此我们可以通过轻量级进程调用内核线程，进而由操作系统内核将任务映射到各个处理器，这种轻量级进程与内核线程间1对1的关系就称为一对一的线程模型。如下图

![8e314dc2a5fd4d058dc668f7f4f01715.jpeg][]

如图所示，每个线程最终都会映射到CPU中进行处理，如果CPU存在多核，那么一个CPU将可以并行执行多个线程任务。

#### Java内存模型与硬件内存架构的关系 ####

通过对前面的硬件内存架构、Java内存模型以及Java多线程的实现原理的了解，我们应该已经意识到，多线程的执行最终都会映射到硬件处理器上进行执行，但Java内存模型和硬件内存架构并不完全一致。

对于硬件内存来说只有寄存器、缓存内存、主内存的概念，并没有工作内存(线程私有数据区域)和主内存(堆内存)之分，也就是说Java内存模型对内存的划分对硬件内存并没有任何影响，因为JMM只是一种抽象的概念，是一组规则，并不实际存在，

不管是工作内存的数据还是主内存的数据，对于计算机硬件来说都会存储在计算机主内存中，当然也有可能存储到CPU缓存或者寄存器中，因此总体上来说，Java内存模型和计算机硬件内存架构是一个相互交叉的关系，是一种抽象概念划分与真实物理硬件的交叉。(注意对于Java内存区域划分也是同样的道理)

![0b948dbb21a3472bb2c4752e52a73098.png][]

当对象和变量可以存储在计算机的各种不同存储区域中时，可能会出现某些问题。两个主要问题是：

*  线程更新（写入）共享变量的可见性。
 *  读取，检查和写入共享变量时的竞争条件。

#### 共享对象的可见性 ####

如果两个或多个线程共享一个对象，而没有正确使用 `volatile` 声明或同步，则一个线程对共享对象的更改对于在其他CPU上运行的线程是不可见的。

这样，每个线程最终都可能拥有自己的共享对象副本，每个副本都位于不同的CPU缓存中，并且其中的内容不相同。

下图简单说明了情况。在左边CPU上运行的一个线程将共享对象复制到其CPU缓存中，并将其 `count` 变量更改为2。此更改对于在CPU上运行的其他线程不可见，因为`count`的更新尚未刷新回主内存。

![50127067ffc9499bbd59a6c473ae6d11.png][]

要解决此问题，您可以使用Java的volatile关键字。`volatile` 关键字可以确保变量从主内存中直接读取而不是从缓存中，并且更新的时候总是立即写回主内存。

竞争条件

> 如果两个或多个线程共享一个对象，并且多个线程更新该共享对象中的成员变量，则可能会出现[竞争条件][Link 1]。

想象一下，如果线程A将共享对象的变量`count`读入其CPU缓存中。再想象一下，线程B也做了同样的事情，但是进入到了不同的CPU缓存。现在线程A添加一个值到`count`，线程B执行相同的操作。现在`var1`已经增加了两次，每次CPU缓存一次。

如果这些增加操作按顺序执行，则变量`count`将增加两次并将”原始值+ 2”后产生的新值写回主存储器。

但是，两个增加操作同时执行却没有进行适当的同步。无论线程A和B中的哪一个将其更新版本`count`写回主到存储器，更新的值将仅比原始值多1，尽管有两个增加操作。

> 该图说明了如上所述的竞争条件问题的发生：

![e176de0973c84e588fd8e08d07480225.png][]

要解决此问题，您可以使用[Java synchronized块][Java synchronized]。同步块保证在任何给定时间只有一个线程可以进入代码的临界区。同步块还保证在同步块内访问的所有变量都将从主存储器中读入，当线程退出同步块时，所有更新的变量将再次刷新回主存储器，无论变量是否声明为volatile。

### JMM存在的必要性 ###

在明白了Java内存区域划分、硬件内存架构、Java多线程的实现原理与Java内存模型的具体关系后，接着来谈谈Java内存模型存在的必要性。

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间)，用于存储线程私有的数据，线程与主内存中的变量操作必须通过工作内存间接完成，主要过程是将变量从主内存拷贝的每个线程各自的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，如果存在两个线程同时对一个主内存中的实例对象的变量进行操作就有可能诱发线程安全问题。

如下图，主内存中存在一个共享变量x，现在有A和B两条线程分别对该变量x=1进行操作，A/B线程各自的工作内存中存在共享变量副本x。

假设现在A线程想要修改x的值为2，而B线程却想要读取x的值，那么B线程读取到的值是A线程更新后的值2还是更新前的值1呢？答案是，不确定，即B线程有可能读取到A线程更新前的值1，也有可能读取到A线程更新后的值2，这是因为工作内存是每个线程私有的数据区域，而线程A变量x时，

首先是将变量从主内存拷贝到A线程的工作内存中，然后对变量进行操作，操作完成后再将变量x写回主内，而对于B线程的也是类似的，这样就有可能造成主内存与工作内存间数据存在一致性问题，假如A线程修改完后正在将数据写回主内存，而B线程此时正在读取主内存，即将x=1拷贝到自己的工作内存中，

这样B线程读取到的值就是x=1，但如果A线程已将x=2写回主内存后，B线程才开始读取的话，那么此时B线程读取到的就是x=2，但到底是哪种情况先发生呢？这是不确定的，这也就是所谓的线程安全问题。

![b331a2978fb349ff84363948cfe86dd9.png][]

为了解决类似上述的问题，JVM定义了一组规则，通过这组规则来决定一个线程对共享变量的写入何时对另一个线程可见，这组规则也称为Java内存模型（即JMM），JMM是围绕着程序执行的原子性、有序性、可见性展开的，下面我们看看这三个特性。

[95d03be5744b4aa48a4f2499b64e8e24.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/76923882989441e9a500cc875514762f.png
[c06b8de1a13d49d7b9121a1e36afb7a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/74bec91d49db49b79c2a0a991c741b71.png
[8f6bb11303e341e6ad1504f69f9a0c51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0f4620682f50481eb19862cc19315d8e.png
[f549d41a61624f8d838a74b29cc815bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/8bc26265fc3c426fb0a8b280fb251227.png
[bc47759625bb41e7a79b5ff8334a858b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c17f26c03b5441298fef895ec9d6b2ab.png
[edb8e8486ac7455ba0524c8fed11ea3e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/da995ad34277444e97e14146cd13b34d.png
[bcf21459423a48d387c86e635f0f2a04.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0b0123e4ddb549648946df677eaede62.png
[dfc99c86d1524053b3e22b0b0d8ff6e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/855174efb34e437b9a61eb4c37f87809.png
[8e314dc2a5fd4d058dc668f7f4f01715.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/02e86860ea284c52b77e6d8964122f5a.png
[0b948dbb21a3472bb2c4752e52a73098.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c5df08b2a47a40b1b698270f14615a0c.png
[50127067ffc9499bbd59a6c473ae6d11.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/667f0e4eb21a4c70a822e4045d370c4c.png
[Link 1]: https://link.juejin.cn?target=http%3A%2F%2Ftutorials.jenkov.com%2Fjava-concurrency%2Frace-conditions-and-critical-sections.html
[e176de0973c84e588fd8e08d07480225.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2667d58a7d6c4a199fb70d59d26dbf16.png
[Java synchronized]: https://link.juejin.cn?target=http%3A%2F%2Ftutorials.jenkov.com%2Fjava-concurrency%2Fsynchronized.html
[b331a2978fb349ff84363948cfe86dd9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2e035e5184ab45d2adeea21f8d808d97.png