【多线程进阶】

💡 摘要：你是否曾尝试学习 Java 多线程，却被“线程安全”、“竞态条件”、“内存可见性”等术语搞得一头雾水？ 或者写了一个看似正确的多线程程序，却在运行时出现诡异的 bug，难以复现？ 问题往往不在于“多线程本身太难”，而在于基础知识不牢固。 在正式踏入 Thread、Runnable、synchronized 的世界之前，必须先打好地基。 本文将系统梳理学习 Java 多线程前必须掌握的 6 大核心前置知识：从 JVM 内存模型、CPU 缓存架构，到原子性、可见性、有序性三大特性，再到 volatile 和 synchronized 的底层原理。 只有理解了这些“底层逻辑”，你才能真正驾驭多线程编程，写出高效、安全的并发代码。 文末附面试高频问题解析，助你打通任督二脉。

一、为什么多线程这么难？——从“直觉”到“现实”的鸿沟

我们习惯于顺序编程：代码从上到下执行，结果可预测。 但多线程打破了这一“直觉”：

// 你以为的：
int a = 0;
a++; // a 变成 1

// 多线程下的现实：
// 两个线程同时执行 a++，结果可能不是 2！

❌ 问题根源：

• CPU 缓存导致变量修改对其他线程不可见
• 指令重排序打乱了代码执行顺序
• 非原子操作（如 a++）可能被中断

在学习 new Thread() 之前，必须先理解这些“破坏直觉”的底层机制。

二、必备知识一：JVM 内存模型（JMM）——并发的“宪法”

Java 内存模型（Java Memory Model, JMM）是理解并发的基石。 它定义了线程如何与内存交互，是 Java 并发编程的“游戏规则”。

1. 主内存与工作内存

• 主内存（Main Memory）：所有线程共享的堆内存，存储变量的“真实值”。
• 工作内存（Working Memory）：每个线程私有的内存（可理解为 CPU 缓存 + 寄存器），存储变量的“副本”。

// 共享变量
int sharedVar = 0; // 存储在主内存

// 线程操作流程：
// 1. 从主内存读取 sharedVar 到工作内存
// 2. 在工作内存中修改副本
// 3. 将修改后的值写回主内存

🔥 关键点：线程不能直接操作主内存，必须通过工作内存“中转”。

2. JMM 的三大特性

✅ 掌握这三大特性，就掌握了并发问题的“病根”与“药方”。

三、必备知识二：CPU 缓存与内存屏障——性能与一致性的博弈

1. 为什么需要 CPU 缓存？

• CPU 速度 >> 内存速度
• 缓存（L1/L2/L3）作为“中间商”，大幅提升访问速度
• 但多核 CPU 的缓存是独立的！

CPU 0: [L1 Cache] → [L2 Cache] → [主内存]
CPU 1: [L1 Cache] → [L2 Cache] → [主内存]

⚠️ 问题：线程 A（在 CPU 0）修改变量，线程 B（在 CPU 1）可能读到旧值——可见性问题。

2. 缓存一致性协议（如 MESI）

硬件层面通过协议（如 MESI）保证缓存一致性，但：

• 延迟存在：更新不会立即同步到其他 CPU
• 性能开销：同步过程消耗资源

🔑 结论：不能依赖硬件自动保证“实时可见”，需编程语言层面（如 JMM）提供更强保证。

3. 内存屏障（Memory Barrier）

一种 CPU 指令，用于控制读写操作的顺序，防止重排序。

• LoadLoad：确保后续读操作在之前读之后
• StoreStore：确保后续写操作在之前写之后
• LoadStore：确保后续写操作在之前读之后
• StoreLoad：确保后续读操作在之前写之后（最强屏障）

✅ volatile 关键字的实现就依赖内存屏障。

四、必备知识三：原子性（Atomicity）——“不可分割”的操作

1. 什么是原子性？

一个操作要么全部执行，要么完全不执行，不会被线程调度机制打断。

2. 哪些操作是原子的？

3. 如何保证原子性？

• synchronized：加锁，确保同一时刻只有一个线程执行
• java.util.concurrent.atomic 包：如 AtomicInteger，基于 CAS（Compare-And-Swap）实现无锁原子操作

AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.incrementAndGet(); // 原子自增

五、必备知识四：可见性（Visibility）——让修改“被看见”

1. 可见性问题演示

public class VisibilityDemo {
    private boolean running = true;

    public void run() {
        while (running) {
            // do work
        }
        System.out.println("Stopped");
    }

    public void stop() {
        running = false;
    }
}

❌ 问题：

• 线程 A 执行 run()，running 变量被缓存到其工作内存
• 线程 B 调用 stop()，修改 running = false
• 线程 A 可能永远看不到 running 的变化，无限循环！

2. 解决方案

✅ 方案一：volatile 关键字

private volatile boolean running = true;

• 作用：
  1. 保证变量的可见性：写操作立即刷新到主内存，读操作强制从主内存读取
  2. 禁止指令重排序

✅ 方案二：synchronized

public synchronized void stop() {
    running = false;
}

public synchronized void run() {
    while (running) { ... }
}

• 同步块的进入（monitorenter）和退出（monitorexit）会强制工作内存与主内存同步。

六、必备知识五：有序性（Ordering）——代码执行的“顺序”之谜

1. 指令重排序

为了提高性能，编译器和 CPU 会对指令进行重排序，只要保证单线程语义不变。

int a = 0;
boolean flag = false;

// 原始代码
a = 1;        // 1
flag = true;  // 2

// 可能被重排序为：
flag = true;  // 2
a = 1;        // 1

⚠️ 多线程下问题：如果另一个线程看到 flag = true，但 a 还是 0，就会出错。

2. happens-before 原则

JMM 定义了先行发生关系，是判断数据是否存在竞争、线程是否安全的基石。

核心规则：

1. 程序次序规则：单线程内，代码顺序即 happens-before 顺序
2. 监视器锁规则：synchronized 的解锁 happens-before 于后续加锁
3. volatile 变量规则：volatile 写 happens-before 于后续 volatile 读
4. 线程启动规则：Thread.start() happens-before 于线程内任何操作
5. 线程终止规则：线程内所有操作 happens-before 于其他线程检测到该线程结束
6. 传递性：A happens-before B，B happens-before C，则 A happens-before C

✅ 如果两个操作没有 happens-before 关系，它们就可能被重排序。

七、必备知识六：volatile 与 synchronized 的底层原理

1. volatile 的实现

• 编译器：在 volatile 变量操作前后插入内存屏障
• 处理器：使用特定指令（如 x86 的 lock 前缀）确保缓存一致性
• 效果：
  • 写：StoreStore + StoreLoad 屏障 → 强制刷新到主内存
  • 读：LoadLoad + LoadStore 屏障 → 强制从主内存读取

2. synchronized 的实现

• 对象头（Mark Word）：存储锁状态（无锁、偏向锁、轻量级锁、重量级锁）
• Monitor（监视器）：每个对象都有一个关联的 Monitor
• 锁升级：JVM 优化，从无锁 → 偏向锁 → 轻量级锁 → 重量级锁
• 进入/退出：monitorenter / monitorexit 指令触发内存同步

🔍 理解这些，才能明白为什么 synchronized 既能保证原子性，又能保证可见性和有序性。

八、总结：构建你的多线程知识地基

在学习 Thread 类和并发工具类之前，务必先掌握以下六大核心前置知识：

🚀 学习路径建议：

1. 先理解 JMM 与三大特性
2. 掌握 volatile 和 synchronized 的原理
3. 再学习 Thread、Runnable、线程池等上层 API
4. 最后深入 java.util.concurrent 包

地基不牢，地动山摇。只有理解了这些底层机制，你才能真正驾驭 Java 多线程，写出既高效又安全的并发程序。

九、高频问题解析

❓1. 什么是 Java 内存模型（JMM）？

答： JMM 是 Java 虚拟机规范定义的，关于线程如何与内存交互的模型。 它屏蔽了硬件和操作系统的内存访问差异，确保 Java 程序在各种平台上行为一致。 核心是主内存与工作内存的抽象，以及原子性、可见性、有序性三大特性。

❓2. volatile 关键字的作用是什么？

答：

1. 保证可见性：对 volatile 变量的写操作会立即刷新到主内存，读操作会强制从主内存读取；
2. 禁止指令重排序：通过内存屏障实现；
3. 不保证原子性：如 volatile i++ 仍不是原子操作。

❓3. synchronized 如何保证可见性和原子性？

答：

• 原子性：通过 Monitor 锁，确保同一时刻只有一个线程执行同步代码块；
• 可见性：根据 happens-before 的监视器锁规则，解锁前的修改对后续加锁的线程可见，JVM 会强制工作内存与主内存同步。

❓4. 什么是 happens-before 原则？为什么重要？

答： happens-before 是 JMM 定义的两个操作之间的偏序关系。 如果 A happens-before B，则 A 的执行结果对 B 可见。 它是判断数据竞争和线程安全的基础。 即使代码重排序，只要 happens-before 关系不变，程序语义就不变。

❓5. long 和 double 的读写一定是原子的吗？

答： 不一定。 根据 JMM，32 位及以下的基本类型读写是原子的。 long 和 double 是 64 位，可能被分为两个 32 位操作，不是原子的。 但 volatile long 和 volatile double 的读写是原子的。

❓6. 指令重排序有什么好处？会带来什么问题？

答：

• 好处：提高 CPU 流水线效率，提升程序性能；
• 问题：在多线程环境下，可能导致程序执行结果与代码顺序不一致，引发竞态条件。 解决方案：使用 volatile、synchronized 等同步机制建立 happens-before 关系，禁止有害重排序。