Java 多线程进阶：什么是线程安全？

在多线程编程中，“线程安全”是一个非常重要但又常被误解的概念。尤其对于刚接触多线程的人来说，不理解线程安全的本质，容易写出“偶尔出错”的代码——这类 bug 往往隐蔽且难以复现。

本文将用尽可能通俗的语言，从三个角度解释线程不安全的常见原因，并提供具体的示例和解决方法。

---

一、什么是线程安全？

线程安全（Thread Safety）简单来说就是：

在多个线程同时执行某段代码时，无论线程怎么调度、怎么交叉执行，都会得到正确的结果，不会出 bug。

线程安全：

多个线程访问相同对象时，不会引起数据不一致或状态混乱。

线程不安全：

同一段代码，在单线程环境下一切正常，但在多线程环境下，结果可能出错或不一致。

---

二、线程不安全的三大根源

1. 原子性问题：操作不是一步完成的

一个典型例子是变量自增 count++。虽然看起来是一条语句，但其实底层是三条指令：

load   // 从内存读取 count 到 CPU 寄存器
add    // 在寄存器中执行 +1 操作
store  // 把结果写回内存

在两个线程同时执行 count++ 时，可能会出现以下竞态（race condition）：

🎯 理想顺序（无竞态）：线程串行执行

时间轴 →
Thread A：load(0) → add(1) → store(1)
Thread B：  load(1) → add(1) → store(2)

最终结果：count = 2（正确，无操作丢失）

---

❌ 竞态情况 1：两个线程都读取了旧值（0）

时间轴 →
Thread A：load(0) → add(1) -----------------> store(1)
Thread B：  load(0) → add(1) -----------------> store(1)

最终结果：count = 1 ❌（两个线程都基于旧值 0 进行计算，结果被覆盖，丢失了一次加法）

---

❌ 竞态情况 2：交错执行导致结果被覆盖

时间轴 →
Thread A：load(0) → add(1) -----------------> store(1)
Thread B：  load(0) → add(1) → store(1)

最终结果：count = 1 ❌（Thread A 的存储操作覆盖了 Thread B 的结果）

---

❌ 竞态情况 3：Thread B 插队执行完毕

时间轴 →
Thread A：load(0) → add(1)
Thread B：  load(0) → add(1) → store(1)
Thread A：  store(1)

最终结果：count = 1 ❌（Thread A 最后写入的值覆盖了 Thread B 的加法结果）

---

❌ 竞态情况 4：Thread A 读值后等待，Thread B 先完成

时间轴 →
Thread A：load(0)
Thread B：  load(0) → add(1) → store(1)
Thread A：  add(1) → store(1)

最终结果：count = 1 ❌（两个线程都基于同一个初始值 0 进行加法，导致一次加法丢失）

解决方案

• 使用 synchronized 同步关键代码块

  synchronized (this) {
      count++;
  }
  

• 使用原子类如 AtomicInteger 实现原子操作

  AtomicInteger count = new AtomicInteger(0);
  count.incrementAndGet(); // 原子性 +1
  

  ---

  3. 指令重排序：执行顺序被优化

  为了提升性能，编译器和 CPU 可能对指令重新排序，只要单线程语义不变即可。但这可能影响多线程环境的执行逻辑。

  例如：

  // 线程 A
  a = 1;
  flag = true;
  
  // 线程 B
  if (flag) {
      System.out.println(a); // 可能输出 0！
  }
  

   

---

2. 可见性问题：变量更新对其他线程不可见

Java 中每个线程都有自己的工作内存（工作缓存），它会缓存主内存中的变量副本。这就导致：

• 一个线程修改了变量，另一个线程却看不到。

例如：

volatile boolean running = true;

public void stop() {
    running = false;
}

public void run() {
    while (running) {
        // 执行某些操作
    }
}

由于重排序，可能发生 flag = true 提前执行，而 a = 1 还没发生，导致 a 为默认值 0。

🛠 解决方案：

• 使用 volatile 修饰 flag，防止指令重排；

• 或使用 synchronized，保证顺序一致；

• 对不可变对象，使用 final 修饰字段也是一种有效方式。

---

三、小结

线程安全问题，来源于我们“看似简单”的代码在多线程环境下可能出现的非预期行为：

• 原子性：多步操作被打断

• 可见性：线程看不到最新值

• 指令重排：操作顺序被调整