Java 内存模型（JMM）概述

最新推荐文章于 2025-11-23 13:27:25 发布

原创最新推荐文章于 2025-11-23 13:27:25 发布 · 311 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

1.1 什么是 JMM？

Java 内存模型（JMM）是一套规定了 Java 程序中各个线程如何交互和共享数据的规则。它定义了多线程环境下：

共享变量的可见性：多个线程间对共享变量的修改是否能被及时地看到。
操作的有序性：多个线程对共享变量的操作执行顺序是否能够按照预期执行。
原子性：线程对共享变量的操作是否是原子的。

Java 内存模型的目标是让开发者不需要关心底层硬件和操作系统的细节，能够确保多线程环境下的程序行为是正确的。

1.2 内存模型的组成

主内存（Main Memory）：所有线程共享的内存区域，所有的实例变量和类变量都存储在这里。
工作内存（Working Memory）：每个线程都有一个独立的工作内存，它存储线程所使用的变量副本。线程对变量的读写操作首先在工作内存中进行，最后再同步到主内存。

JMM 定义了 主内存 与 工作内存 之间的交互规则，通过内存屏障（Memory Barriers）来控制线程间的内存同步。

1.3 JMM 的关键概念

原子性（Atomicity）：
- 原子性指的是程序中某些操作不可被中断，要么全部完成，要么完全不做。
- 对于大多数的操作（如基本类型的赋值、单一的 ++ 操作等），JMM 保证它们的原子性，但对于复合操作（如 i++，a = b + c）则没有保证。
可见性（Visibility）：
- 可见性指的是一个线程对共享变量的修改，是否能被其他线程及时看到。
- Java 内存模型通过 volatile 关键字和 synchronized 关键字来确保可见性。
有序性（Ordering）：
- 有序性是指程序中的操作按照特定顺序执行，在多线程环境下，不同线程的执行顺序是否能够被合理安排，避免由于 JVM 或 CPU 的优化导致程序逻辑错乱。
- JMM 通过 happens-before 关系来保证操作的有序性。

二、内存可见性与顺序性

2.1 内存可见性

多个线程对共享变量的修改，不一定能够立即反映到其他线程。每个线程都有自己独立的工作内存，线程对共享变量的读写操作首先发生在工作内存中，修改后的数据不会立刻同步到主内存。这就可能导致不同线程看到不同的变量值。

举个例子：

class Counter {
    private int count = 0;

    public void increment() {
        count++;  // 非原子操作
    }

    public int getCount() {
        return count;
    }
}

假设两个线程都执行 increment() 操作，它们可能会读到相同的 count 值，进行自增后，都会写回相同的 count 值，导致丢失更新。

如何解决可见性问题？

使用 volatile 关键字：
- volatile 关键字保证了当一个线程修改了变量时，其他线程可以立即看到该修改。
- 但 volatile 并不保证原子性，它只是保证可见性。
```
private volatile boolean flag = false;
```
使用 synchronized 关键字：
- synchronized 不仅保证可见性，还能保证对共享变量的操作是原子的。
- 进入同步块之前，线程会从主内存中读取共享变量的最新值，退出同步块时会将更新后的值写回主内存。
使用 Lock（如 ReentrantLock）：
- Lock 比 synchronized 更加灵活，支持更加细粒度的锁操作，但本质上也依赖于 JVM 内部的内存屏障来保证内存的可见性和有序性。

2.2 顺序性

顺序性问题的核心在于指令重排。现代的 JVM 和 CPU 会为了性能优化，对程序中的指令进行重排序（如编译器优化和 CPU 层面的乱序执行）。这可能导致程序执行顺序与代码顺序不一致。

举个例子：

int a = 0;
boolean flag = false;

public void example() {
    a = 1;  // 写操作
    flag = true;  // 写操作
}

public void reader() {
    if (flag) {
        System.out.println(a);  // 读操作
    }
}

如果不做任何同步处理，在某些 CPU 上，a = 1 和 flag = true 可能会发生指令重排，导致 flag 被设为 true 之前，a 的值就被读取，从而出现程序逻辑上的错误。

如何解决顺序性问题？

volatile 保证写操作先于读操作：
- 对于 volatile 变量的写操作，JMM 保证所有的写操作先于之后的读操作。
synchronized 保证操作顺序：
- synchronized 块也会禁止指令重排。进入和退出同步块时，会添加内存屏障，从而保证操作的顺序性。
happens-before 关系：
- happens-before 是 JMM 中定义的一个概念，用来描述两个操作的顺序关系。它保证了某个操作一定会在另一个操作之前发生，并且能够被其他线程观察到。
例如：
- 一个线程的 写操作 对于另一个线程的 读操作，如果前者在后者之前执行，那么写操作的结果将被读操作所看到。

2.3 `volatile` 和 `synchronized` 的区别

特性	`volatile`	`synchronized`
保证	可见性（保证线程可见性，禁止缓存）	可见性 + 原子性 + 顺序性
性能	较高，但只适用于单一变量的读写	相对较低，尤其在高并发时
使用场景	适用于简单的标志位、状态变量等	适用于复杂的同步操作，防止竞态条件
原子性	不保证原子性	保证原子性

三、CPU 缓存一致性

3.1 MESI 协议

在多核 CPU 系统中，每个核心都有自己的缓存，为了确保缓存一致性，必须有协议来协调不同核心间缓存的操作，避免出现缓存不一致的问题。最常见的协议是 MESI 协议。

MESI 协议的四种状态：

Modified (M)：该缓存行被修改，并且是唯一的副本。修改后的数据尚未写回主内存。
Exclusive (E)：该缓存行只在该核心中存在，并且与主内存中的数据一致。此时核心有对该缓存行的独占访问权限。
Shared (S)：该缓存行可能被多个核心共享，且与主内存中的数据一致。
Invalid (I)：该缓存行无效。

3.2 MESI 与 Java 内存模型

JMM 与 MESI 协议之间存在紧密的关系。当我们使用 volatile 或 synchronized 等机制来控制变量的可见性时，底层的 CPU 缓存一致性协议实际上起到了至关重要的作用。

例如，在多核系统中，当一个线程修改了 volatile 变量时，JMM 要求立即将该变量的值从工作内存刷新到主内存，确保其他线程能够看到该修改。此时，MESI 协议会确保缓存中的值在多个 CPU 核心间保持一致。

四、总结与最佳实践

理解 JMM 的工作原理，特别是内存可见性和顺序性的重要性，能够帮助我们设计更加可靠的并发程序。
合理使用 volatile 和 synchronized，分别解决可见性和顺序性的问题。对于简单的状态变量，使用 volatile 即可；对于需要复合操作的同步，使用 synchronized 或显式的Lock。
底层的缓存一致性协议（如 MESI） 在实际多核处理器上发挥了重要作用，我们需要通过 JMM 的机制来确保 Java 程序的并发安全性。

在并发编程中，避免竞态条件和确保程序正确性，是最为重要的。掌握 Java 内存模型及其与硬件层面缓存一致性的关系，能够让我们写出更加高效和安全的并发程序。