java内存模型

最新推荐文章于 2025-09-03 23:14:03 发布

埃泽漫笔

最新推荐文章于 2025-09-03 23:14:03 发布

阅读量716

点赞数 22

CC 4.0 BY-SA版权

分类专栏： # jvm 文章标签： java jvm

本文链接：https://blog.csdn.net/jonas80029735/article/details/151084527

jvm 专栏收录该内容

43 篇文章

订阅专栏

题目详细答案

Java 内存模型（Java Memory Model, JMM）是 Java 虚拟机规范的一部分，定义了多线程环境下共享变量的访问规则以及不同线程之间如何通过内存进行交互。JMM 主要解决在多线程编程中可能出现的可见性、原子性和有序性问题。

关键概念

线程与主内存：

每个线程都有自己的工作内存（也称为本地内存），工作内存保存了该线程使用到的变量的副本。主内存是共享内存区域，所有线程都可以访问主内存中的变量。

可见性：

可见性问题是指一个线程对共享变量的修改，另一个线程是否能够立即看到。JMM 通过volatile关键字、锁机制（如synchronized）等来保证变量的可见性。

原子性：

原子性问题是指一个操作是否是不可分割的，即操作要么全部执行完成，要么完全不执行。JMM 保证了基本数据类型的读写操作的原子性，但对于复合操作（如 i++）则不保证。

有序性：

有序性问题是指代码执行的顺序是否与程序的顺序一致。编译器和处理器可能会对指令进行重排序，以提高性能。JMM 通过volatile关键字、锁机制等来保证必要的有序性。

内存模型中的同步机制

volatile关键字

volatile变量保证了对该变量的读写操作的可见性和有序性。

读volatile变量时，总是从主内存中读取最新的值。

写volatile变量时，总是将最新的值写回主内存。

synchronized关键字：

synchronized块或方法保证了进入临界区的线程对共享变量的独占访问。

退出synchronized块时，会将工作内存中的变量更新到主内存。

进入synchronized块时，会从主内存中读取最新的变量值。

final关键字：

final变量在构造器中初始化后，其他线程可以立即看到初始化后的值。

final变量的引用不会被修改，因此可以确保其可见性。

可见性问题示例

public class VisibilityExample {
    private static boolean stop = false;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!stop) {
                // busy-wait
            }
        });
        thread.start();

        Thread.sleep(1000);
        stop = true; // 另一个线程可能不会立即看到这个修改
    }
}

主线程修改了stop变量，但另一个线程可能不会立即看到修改，导致循环无法终止。可以使用volatile关键字解决这个问题：

public class VisibilityExample {
    private static volatile boolean stop = false;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!stop) {
                // busy-wait
            }
        });
        thread.start();

        Thread.sleep(1000);
        stop = true; // 另一个线程会立即看到这个修改
    }
}

Java 内存模型（JMM）详解：多线程内存交互的核心规则

Java 内存模型（Java Memory Model, JMM）是 Java 虚拟机规范中定义的一套抽象模型，用于解决多线程环境下共享变量的访问一致性问题。它通过规范线程与内存之间的交互规则，确保多线程程序在不同硬件和操作系统上的正确性和可移植性。本文将深入解析 JMM 的核心概念、解决的问题及关键实现机制。

一、JMM 的核心目标

在单线程程序中，变量的读写操作具有明确的顺序和可见性，但多线程场景下，由于以下原因会导致数据访问的不确定性：

线程私有工作内存与主内存的同步延迟；
编译器和处理器为优化性能进行的指令重排序；
多核 CPU 缓存不一致性。

JMM 的核心目标是定义线程对共享变量的访问规则，解决多线程编程中的三大问题：

可见性：一个线程对共享变量的修改，其他线程能否立即感知；
原子性：一个操作是否不可分割（要么全执行，要么全不执行）；
有序性：程序执行顺序是否与代码逻辑顺序一致。

二、JMM 的核心概念：内存与线程的交互模型

JMM 定义了 “主内存” 和 “工作内存” 的抽象划分，用于规范线程对共享变量的访问流程：

1. 内存划分

主内存（Main Memory）：所有线程共享的内存区域，存储共享变量（实例变量、静态变量等，局部变量因线程私有不涉及）。
工作内存（Working Memory）：每个线程独有的内存区域，存储该线程使用的共享变量的副本（从主内存加载）。线程对变量的所有操作（读、写）都必须在工作内存中进行，不能直接操作主内存。

2. 线程与内存的交互操作

JMM 定义了 8 种原子操作（由 JVM 实现），用于规范工作内存与主内存之间的变量传递：

lock（锁定）：将主内存中的变量标记为 “线程独占”；
unlock（解锁）：将主内存中 “线程独占” 的变量释放，允许其他线程访问；
read（读取）：将主内存的变量值传输到线程的工作内存；
load（加载）：将 read 得到的值存入工作内存的变量副本中；
use（使用）：将工作内存中的变量值传递给线程的执行引擎（如用于计算）；
assign（赋值）：将执行引擎的结果赋值给工作内存中的变量；
store（存储）：将工作内存的变量值传输到主内存；
write（写入）：将 store 得到的值存入主内存的变量中。

操作约束：

对一个变量执行 lock 后，必须先执行 unlock 才能再次 lock；
assign 操作后，必须执行 store 和 write 才能将修改同步到主内存；
线程对变量的 use 必须基于最新的 load 结果（即工作内存副本需与主内存同步）。

三、JMM 解决的三大问题及实现机制

1. 可见性：确保变量修改的跨线程感知

问题描述：线程 A 修改了共享变量 x 并写入工作内存，但未及时同步到主内存；线程 B 从主内存读取 x 时，拿到的仍是旧值，导致 “修改不可见”。

示例：

// 可见性问题演示：线程 B 可能永远无法退出循环
public class VisibilityDemo {
    private static boolean flag = false; // 共享变量

    public static void main(String[] args) throws InterruptedException {
        // 线程 B：循环等待 flag 变为 true
        Thread B = new Thread(() -> {
            while (!flag) { 
                // 若 flag 未被标记为 volatile，线程 B 可能一直读取工作内存的旧值
            }
            System.out.println("Thread B exit");
        });
        B.start();

        // 线程 A：1 秒后修改 flag 为 true
        Thread.sleep(1000);
        flag = true;
        System.out.println("Thread A set flag to true");
    }
}

解决机制：
JMM 通过以下方式保证可见性：

volatile 关键字：
当变量被声明为 volatile 时，JMM 会强制线程在写入该变量后立即执行 store 和 write（同步到主内存），并在读取前执行 read 和 load（从主内存刷新），确保其他线程能立即看到最新值。
（上述示例中，将 flag 声明为 volatile static boolean flag = false 即可解决问题。）
synchronized 关键字：
线程退出 synchronized 块时，会自动将工作内存的变量修改同步到主内存（类似 store + write）；进入 synchronized 块时，会从主内存刷新变量到工作内存（类似 read + load），从而保证可见性。
final 关键字：
final 变量一旦在构造器中初始化完成（且构造器未逸出 this 引用），其他线程读取时一定能看到其初始化后的值（不可修改性保证了可见性）。

2. 原子性：确保操作的不可分割性

问题描述：一个 “复合操作”（如 i++）在底层可能被拆分为多个步骤（读 i、加 1、写回 i），多线程并发执行时可能出现中间状态被干扰的情况。

示例：

// 原子性问题演示：1000 个线程各执行 1000 次 i++，结果可能小于 1000000
public class AtomicityDemo {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                count++; // 复合操作：读 -> 加 1 -> 写
            }
        };

        // 启动 1000 个线程
        Thread[] threads = new Thread[1000];
        for (int i = 0; i < 1000; i++) {
            threads[i] = new Thread(task);
            threads[i].start();
        }
        // 等待所有线程结束
        for (Thread t : threads) t.join();
        System.out.println("count = " + count); // 预期 1000000，实际可能更小
    }
}

解决机制：
JMM 本身仅保证基本数据类型的读写操作（如 int a = b）的原子性，复合操作需通过以下方式保证原子性：

synchronized 关键字：
synchronized 块或方法会保证同一时间只有一个线程进入临界区，使临界区内的所有操作成为一个不可分割的原子操作（如上述示例中，将 count++ 放入 synchronized 块即可保证结果正确）。
锁机制（如 ReentrantLock）：
显式锁与 synchronized 原理类似，通过独占访问保证临界区操作的原子性。
原子类（如 java.util.concurrent.atomic）：
底层基于 CPU 原子指令（如 CAS）实现，无需加锁即可保证复合操作的原子性（如 AtomicInteger 的 incrementAndGet() 方法可替代 i++）。

3. 有序性：禁止不合理的指令重排序

问题描述：为优化性能，编译器、CPU 可能会对指令进行 “重排序”（不影响单线程执行结果的前提下调整顺序），但多线程场景下可能导致逻辑错误。

示例：

// 有序性问题演示：重排序可能导致线程 B 看到 "b=2, a=0"
public class OrderingDemo {
    private static int a = 0, b = 0;
    private static int x = 0, y = 0;

    public static void main(String[] args) throws InterruptedException {
        while (true) {
            a = 0; b = 0; x = 0; y = 0;
            Thread t1 = new Thread(() -> {
                // 可能被重排序为：b=1; a=1;
                a = 1;
                x = b;
            });
            Thread t2 = new Thread(() -> {
                // 可能被重排序为：a=1; b=1;
                b = 1;
                y = a;
            });
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            // 正常逻辑下 x 和 y 不可能同时为 0，但重排序可能导致 x=0 且 y=0
            if (x == 0 && y == 0) {
                System.out.println("出现有序性问题：x=0, y=0");
                break;
            }
        }
    }
}

解决机制：
JMM 通过以下方式保证有序性：

volatile 关键字：
volatile 变量会禁止编译器和处理器对其前后的指令进行重排序（通过插入内存屏障实现），确保指令执行顺序与代码逻辑一致。
synchronized 关键字：
由于 synchronized 保证同一时间只有一个线程执行临界区代码，相当于强制代码按顺序执行，避免了重排序导致的问题。
happens-before 原则：
JMM 定义的一组 “天然有序” 规则，无需显式同步即可保证有序性（见下文详解）。

四、happens-before 原则：JMM 的核心有序性保证

JMM 引入 “happens-before”（先行发生）原则，定义了两个操作之间的偏序关系：如果操作 A happens-before 操作 B，则 A 的执行结果对 B 可见，且 A 的执行顺序在 B 之前。

以下是关键的 happens-before 规则：

程序顺序规则：同一线程中，代码按书写顺序，前面的操作 happens-before 后面的操作；
volatile 规则：对 volatile 变量的写操作 happens-before 后续对该变量的读操作；
锁规则：解锁操作 happens-before 后续对同一锁的加锁操作；
线程启动规则：Thread.start() 操作 happens-before 线程内的所有操作；
线程终止规则：线程内的所有操作 happens-before 其他线程检测到该线程终止（如 Thread.join() 返回）；
传递性：若 A happens-before B，且 B happens-before C，则 A happens-before C。

示例：
根据 “锁规则”，线程 A 释放锁后，线程 B 获取同一锁时，A 在临界区的操作结果对 B 可见，且顺序上 A 的操作先于 B。

五、JMM 中的同步机制总结

机制	可见性保证	原子性保证	有序性保证	适用场景
volatile	是（强制主内存同步）	否（仅保证单次读写原子性）	是（禁止重排序）	标记状态变量（如开关、标志）
synchronized	是（锁释放 / 获取时同步内存）	是（临界区操作原子化）	是（单线程执行临界区）	复合操作、复杂临界区
final	是（初始化后可见）	是（不可修改）	是（初始化顺序固定）	常量、不可变对象
原子类	是（基于 CAS 操作同步）	是（提供原子化复合操作）	是（禁止重排序）	简单计数器、状态标记