Java虚拟机原理（中）-揭开Java内存运作的神秘面纱

作为一名资深Java开发者，对JVM内存分配及访问机制有着深入的理解无疑将让你的代码运行更加高效。今天，我们就一起揭开Java内存模型的神秘面纱，彻底解锁运行时内存管理的精髓!

这篇博文的主要内容包括:

1. 方法执行时，栈帧的创建和内存分配过程
2. Java内存模型(JMM)的工作原理及重排序规则
3. 通过字节码和JMM理解程序的实际运行顺序

一、进入栈深处:栈帧及方法调用揭秘

1、 栈帧 - 为方法服务的内存区域

每当一个方法被调用时，JVM都会为它分配一个栈帧，用于存放局部变量表、操作数栈等数据。栈帧就是方法执行的内存空间，是线程私有的。

int calculate(int x， int y) {
    int a = x + y; // 局部变量a存放在局部变量表
    int b = 4;
    return a * b; // 通过操作数栈计算表达式值
}

通过JVM指令，我们可以清晰地看到计算的每个步骤是如何使用局部变量表和操作数栈的。

2 、栈帧的创建和复用

方法调用时，会为新方法创建新的栈帧并压入线程栈;方法返回时，会重用站在帧上面的栈帧，节省创建和销毁开销。

public void method1() {
    method2(1，3); // 创建新的栈帧
    System.out.println("Exit method 1"); // 复用method1栈帧
}

public void method2(int x， int y) {
    int temp = x + y; // 使用method2的局部变量表和操作数栈
}

3 、方法内联优化

一些简单方法的调用，JVM也会直接复制方法代码到调用处来节省压栈和方法返回的开销，这称为内联。

public static void main(String[] args){
    int y = f(3); // f()被内联到这里
}       

public static int f(int x){
    return 2*x;  
}

栈帧和内联机制的存在，让我们可以从字节码层面彻底解密方法执行的内存策略。

二、揭开JMM的神秘面纱

除了线程本地的方法栈外，我们还需要关注跨线程共享的内存访问，这就牵涉到JMM的工作原理。

1 、JMM的三大角色

Java内存模型（Java Memory Model， JMM）是Java并发编程的核心部分，它定义了Java虚拟机（JVM）中各种变量（线程共享变量）的访问规则，以及这些变量如何与计算机内存结构（如寄存器、高速缓存、主内存）交互。

JMM的三个主要角色是：

（1）、主内存（主存）

• 定义： 主内存是Java虚拟机中的一块共享内存区域，所有线程都可以访问。它主要用于存储线程共享变量，例如实例字段、静态字段等。

• 作用：

  • 存储共享变量的值。
  • 作为线程间通信的媒介，保证变量的可见性。

• 访问规则：

  • 线程对共享变量的所有操作都必须通过主内存来进行。
  • 线程不能直接操作其他线程存储在主内存中的变量，必须通过工作内存来间接访问。

（2）、线程私有的工作内存（高速缓存）

• 定义： 工作内存是每个线程的私有数据区域，它保存了该线程使用到的变量的副本。线程对这些变量的所有操作都是在工作内存中进行的，然后将结果同步回主内存。

• 作用：

  • 为线程提供操作共享变量的快速访问。
  • 减少线程对主内存的直接操作，降低主内存的访问冲突。

• 访问规则：

  • 线程只能操作自己工作内存中的变量。
  • 线程在操作共享变量前，必须先从主内存中读取到工作内存，操作完成后再将变量写回主内存。

（3）、各种交互操作

• 定义： 交互操作是指线程如何通过特定的操作来确保共享变量的原子性、可见性和有序性。

• 作用：

  • 确保在并发环境下，线程对共享变量的操作能够正确同步。
  • 防止由于线程内部缓存导致的不一致性问题。

• 主要操作：

  • 读取（Read）：从主内存中读取一个变量的值到工作内存。

  • 加载（Load）：将工作内存中的变量值传送到线程的寄存器。

  • 使用（Use）：线程执行变量的操作。

  • 赋值（Assign）：将计算结果赋值给工作内存中的变量。

  • 存储（Store）：将寄存器中的变量传送到工作内存。

  • 写入（Write）：将工作内存中的变量写回主内存。

  • 同步（Synchronize）：与主内存进行同步，确保变量的一致性。

2、理解JMM的重要性

理解JMM对于编写正确的并发程序至关重要。它帮助开发者理解在多线程环境下，如何正确地管理线程之间的数据交互，避免诸如数据竞争、内存不一致、死锁等问题。

假设有两个线程A和B，它们需要共享一个变量x。在JMM下，它们的交互可能如下：

（1）、线程A首先从主内存读取x的值到自己的工作内存。

（2）、线程A在自己的工作内存中对x进行操作，比如x = x + 1。

（3）、线程A将操作后的x的值写回主内存，这样其他线程（比如线程B）就可以看到最新的值。

在这个过程中，JMM确保了x的值在线程A和B之间是一致的，即使它们在不同的工作内存中操作。

通过理解JMM的这三个角色以及它们之间的交互操作，开发者可以更好地控制并发程序的行为，提高程序的性能和可靠性。

3 、八种交互操作行为

Java内存模型（JMM）定义了一组原子操作，这些操作确保了在并发编程中，变量在主内存（Main Memory）和工作内存（Working Memory，通常指的是线程栈中的局部变量表）之间的传递能够满足原子性、可见性和有序性的要求。以下是JMM定义的八种基本原子操作：

（1）、lock（锁定）

• 作用：确保一个线程在对主内存中的变量进行操作时，其他线程不能进行访问。

• 目的：提供原子性，防止多个线程同时修改同一个变量。

（2）、unlock（解锁）

• 作用：释放一个线程对主内存中变量的锁定，允许其他线程访问该变量。

• 目的：结束当前线程的独占模式，允许其他线程进行操作。

（3）、read（读取）：

• 作用：从主内存中读取一个变量的值到线程的工作内存中。

• 目的：为后续的load或assign操作提供数据。

（4）、load（载入）

• 作用：将read操作读取的值从工作内存的临时存储区移动到线程局部变量中。

• 目的：使线程能够操作主内存中的变量副本。

（5）、use（使用）

• 作用：把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的指令时将会执行这个操作。

• 目的：线程执行计算时使用变量的值。

（6）、assign（赋值）

• 作用：将一个从执行引擎接收到的值赋给工作内存中的变量。
• 目的：更新工作内存中的变量副本，为后续的store操作做准备。

（7）、store（存储）

• 作用：将工作内存中变量的值放入主内存中，为write操作做准备。

• 目的：准备将更新后的值写回主内存。

（8）、write（写入）

• 作用：将store操作的值从工作内存放入主内存的变量中。
• 目的：更新主内存中的变量，使其他线程能够看到最新的值。

这些操作是构建在JMM之上的并发控制机制的基础。它们确保了在多线程环境中，对共享变量的操作能够安全地执行，并且能够被其他线程看到。这对于避免数据竞争、保证程序的线程安全性至关重要。

假设有两个线程，线程1和线程2，它们需要对共享变量sharedVar进行操作：

（1）、线程1执行

• lock：线程1锁定sharedVar。

• read：线程1从主内存读取sharedVar的值。

• load：线程1将读取的值载入到工作内存。

• assign：线程1在工作内存中对sharedVar进行赋值操作。

• store：线程1将更新后的值存储回工作内存。

• write：线程1将更新后的值写回主内存。

• unlock：线程1解锁sharedVar。

（2）、线程2执行（在线程1解锁之后）

• lock：线程2锁定sharedVar。
• read：线程2从主内存读取最新的sharedVar值。
• load：线程2将读取的值载入到工作内存。
• …（后续操作类似）

通过这样的操作序列，JMM确保了sharedVar在两个线程之间的操作是原子的，并且每个线程都能看到最新的值。这对于维护程序的正确性和性能至关重要。

3 、重排序及happens-before

JVM为了提高运行效率，会对操作序列进行重排序，只要不影响单线程程序的语义，就允许这种重排。不过，对于跨线程的情况，重排序可能会导致可见性问题。为此，JMM定义了happens-before原则，用于限制重排序规则。例如:

• 监视器锁的规则
• volatile变量写操作的规则
• 线程start规则
• 线程join规则

这些原则保证了重排序不会导致指令交错，影响了程序最终的执行结果。

三、理解并发代码执行流程

在Java中，理解并发代码的执行流程，尤其是它们在Java内存模型（JMM）下的行为，是至关重要的。JMM定义了如何在多线程环境中同步和访问共享变量。下面我将通过一个简单的Java代码示例，分析并发代码在JMM模型下的真实执行顺序。

1、示例代码

假设我们有两个线程，ThreadA 和 ThreadB，它们共享一个变量 sharedVar，初始值为0。两个线程都执行以下操作：

int sharedVar = 0;

void increment() {
    sharedVar++; // 操作1
}

2、问题分析

在单线程环境中，sharedVar++ 将执行以下步骤：

（1）、读取 sharedVar 的值到寄存器。

（2）、在寄存器中增加1。

（3）、将增加后的值写回 sharedVar。

然而，在多线程环境中，如果没有适当的同步措施，ThreadA 和 ThreadB 可能会看到不同的执行顺序，导致竞态条件。例如：

（1）、ThreadA 读取 sharedVar 为0。

（2）、ThreadA 还没来得及写回，ThreadB 读取 sharedVar 也为0。

（3）、ThreadB 执行增加操作，写回 sharedVar 为1。

（4）、ThreadA 执行增加操作，写回 sharedVar 也为1。

最终结果是 sharedVar 为1，而不是预期的2。

3、JMM下的执行顺序

在JMM下，为了确保操作的原子性、可见性和有序性，我们可以使用synchronized关键字或java.util.concurrent包中的原子类。下面是使用synchronized的示例：

int sharedVar = 0;

synchronized void increment() {
    sharedVar++; // 操作1
}

使用synchronized后，increment方法成为管程（Monitor）的一部分。当ThreadA进入该方法时，它会首先尝试获取锁，如果锁已经被ThreadB持有，则ThreadA将被阻塞，直到锁被释放。这样保证了同一时间只有一个线程可以执行increment方法。

（1）、执行顺序分析

• 第一步，ThreadA开始执行，获取锁。

• 第二步，ThreadA读取 sharedVar（值为0）。

• 第三步，ThreadA在工作内存中增加 sharedVar 的值。

• 第四步，ThreadA将增加后的值写回主内存中的 sharedVar。

• 第五步，ThreadA释放锁。

• 第六步，ThreadB现在可以获取锁并执行相同的步骤。

（2）、原子性保证

通过使用synchronized，我们确保了sharedVar++操作是原子的，即不可分割的。此外，synchronized还保证了内存的可见性，即一个线程对共享变量的修改对其他线程是可见的。

（3）、有序性保证

在Java中，synchronized还隐含地保证了有序性。即使编译器和处理器可能会对操作进行重排序，但在同步块内的操作将按照程序的顺序执行。

通过这个示例，我们可以看到，在JMM下，适当的同步措施（如synchronized）对于确保并发代码的正确性至关重要。它帮助我们管理在多线程环境中共享变量的原子性、可见性和有序性，从而避免竞态条件和其他并发问题。在实际编程中，我们还需要考虑其他并发工具和机制，如volatile关键字、锁（Locks）、屏障（Barriers）等，来进一步控制并发程序的行为。

四、延伸思考

' 通过本文，我们对JVM内存管理策略已有了比较深入的理解。不过，这仅仅是冰山一角。JVM内存模型的细节还有很多值得我们去学习和探讨的地方，比如JMM内存语义抽象、内存间交互协议等。有兴趣的读者不妨继续延伸学习，让自己成为Java内存领域的专家!