外观
01 - 线程安全到底在保护什么
适用 JDK:JDK 8+。示例在 JDK 8、11、17 的并发语义一致。
本文是专题入口。先理解多个线程如何访问同一份可变数据,再判断哪些业务规则必须在并发下保持成立。
摘要
两个请求同时扣减最后一件库存,为什么都能成功?每个请求都通过了检查,但检查结果可能在扣减前已经失效。本文用库存场景解释共享可变状态、竞态条件和业务不变量,再比较 volatile、锁、CAS 和数据库条件更新的保护范围。
1. 场景引入:库存是 1,却成功下了两单
一次限量活动上线后,监控里的商品库存出现了负数。代码看起来很自然:
java
public boolean deduct() {
if (stock > 0) {
stock--;
return true;
}
return false;
}这里的 stock 是多个请求共同访问的库存字段,代码是省略了类定义的局部片段。在初始库存非负、没有其他代码修改库存的前提下,单线程会完成一次检查和扣减,再处理下一次调用。
多个线程访问同一份 stock 时,各自的执行步骤却可能交错:线程 A 检查完 stock > 0,还没扣减,线程 B 也完成了检查。两者都认为自己可以买到最后一件商品。下面展示一种可能的执行顺序,并非实测记录。
图表将在阅读到此处时加载…
如果 B 在 A 写入 0 后读取库存并执行扣减,库存可能变成 -1;如果两次扣减都读取 1 并写回 0,库存没有变成负数,但两个请求仍都返回成功。因此,只检查最终库存是否非负,还不足以发现超卖。
这就是竞态条件(Race Condition):程序是否正确取决于多个线程的执行时序。检查和扣减可以被其他请求插入,检查时成立的条件在执行时未必仍然成立。
2. 原理剖析:线程安全保护的是“不变量”
业务不变量是操作前后都必须保持成立的业务规则。在这个库存场景中,保护 stock 的目的,是保证:
库存不能小于 0,且每次成功下单必须与一次有效扣减一一对应。
本文用 deduct() 返回 true 代表扣减成功;实际下单还可能包含订单写入、支付等步骤,这些步骤的一致性不由这个方法单独保证。
如果一个类在多线程访问时,不需要调用方额外协调,仍能始终保持它的正确性约束,我们才说它是**线程安全(Thread Safety)**的。
2.1 先找三个条件
排查并发问题时,可以先问三个问题:
- 是否存在共享状态? 多个线程能否访问同一份数据?
- 状态是否可变? 数据在对象生命期中会不会被修改?
- 是否存在非原子的复合操作? 正确性是否依赖“先检查、再执行”或“读取、修改、写回”?
三者同时存在时,就需要一种并发协调策略。“复合操作”指由多个步骤组成、却必须作为一个整体保持正确的操作。即使没有复合操作,共享可变状态的单次读写也可能需要可见性保证,不能因为第三项不成立就认定安全。
2.2 stock-- 并不是一步
Java 源码里只有一行的 stock--,逻辑上至少包含三步:
text
1. 读取 stock 当前值
2. 计算 stock - 1
3. 将结果写回 stock假设 stock = 10,线程 A 和 B 都读到 10,分别计算出 9,最后两次都写入 9。理论上执行了两次扣减,实际库存却只减少了 1,这种现象称为丢失更新(Lost Update)。
2.3 原子性、可见性、有序性不是一回事
| 性质 | 含义 | 库存场景中的问题 |
|---|---|---|
| 原子性 Atomicity | 对遵守同步协议的其他线程而言,一组操作表现为不可分割的整体 | 检查和扣减被其他线程插入 |
| 可见性 Visibility | 一个线程的写入能被其他线程观察到 | 线程可能继续使用旧值 |
| 有序性 Ordering | 关键操作不会被重排到不允许的位置 | 初始化与发布等场景更常见 |
volatile 可以提供可见性和特定的有序性保证,但不会把“检查后扣减”这组复合操作变成原子操作。
“重排”指编译器或处理器在语义允许的范围内调整操作顺序;“发布”指让其他线程能够取得对象引用。库存例子首先要解决的是原子性:即使读到可见的新值,检查通过后仍可能被其他线程抢先扣减。可见性和发布的具体规则留到后续 JMM 文章展开。
3. 代码实战:复现丢失更新
下面是完整 Java 示例,可保存为 UnsafeCounterDemo.java,在具备 JDK 8+ 的环境中编译运行。这里仅作静态审阅,未实际运行。
示例把库存设为 10,000,向含 16 个工作线程的线程池提交 10,000 次扣减任务,专门观察丢失更新,不再包含库存检查。CountDownLatch 是倒计时同步器:计数归零前,调用 await() 的线程会等待。start 统一放行任务,增加交错执行的机会;done 等待所有任务结束。线程池最多让 16 个任务同时执行,并不是让 10,000 个任务同时开始。
java
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class UnsafeCounterDemo {
private int stock = 10_000;
private void deduct() {
stock--; // 读-改-写,不是原子操作
}
public static void main(String[] args) throws InterruptedException {
UnsafeCounterDemo demo = new UnsafeCounterDemo();
int taskCount = 10_000;
ExecutorService pool = Executors.newFixedThreadPool(16);
CountDownLatch start = new CountDownLatch(1);
CountDownLatch done = new CountDownLatch(taskCount);
for (int i = 0; i < taskCount; i++) {
pool.execute(() -> {
try {
start.await();
demo.deduct();
} catch (InterruptedException e) {
// 恢复中断标记,不要吞掉中断
Thread.currentThread().interrupt();
} finally {
done.countDown();
}
});
}
start.countDown();
done.await();
pool.shutdown();
pool.awaitTermination(1, TimeUnit.MINUTES);
System.out.println("expected stock = 0");
System.out.println("actual stock = " + demo.stock);
}
}在所有任务都执行了扣减、没有因中断跳过扣减的前提下,正确计数的预期结果是 0。存在丢失更新时,actual stock 可能大于 0,表示部分扣减被覆盖;是否出现以及出现多少取决于实际调度,本文没有提供实测输出。还要注意:
并发 Bug 依赖实际调度,某一次恰好输出 0,不能证明代码是线程安全的。测试只能暴露问题,正确性仍需要从同步语义上证明。
4. 反例:把库存改成 volatile
java
private volatile int stock = 10_000;
public boolean deduct() {
if (stock > 0) {
stock--; // 仍然是复合操作
return true;
}
return false;
}volatile 为字段的读写建立可见性和有序性保证,却不会阻止其他线程进入 deduct()。即使两个线程都读到库存 1,它们也仍可能同时通过检查;读取到写回之间还可能发生丢失更新。因此,修复“读不到写入”和修复“检查后条件失效”需要区分。
volatile 更适合以下场景:
- 状态的写入不依赖它的旧值,例如停止标记;
- 对状态没有“先检查、再执行”这类复合约束;
- 需要安全发布一个已构造完成的对象引用。
安全发布保证其他线程通过该引用观察到应当可见的初始化状态,不会自动保护对象发布后的可变字段。停止标记也只表达状态,不能代替唤醒阻塞线程的机制。
5. 正例一:用 synchronized 保护完整不变量
java
public class SynchronizedInventory {
private int stock;
public SynchronizedInventory(int stock) {
this.stock = stock;
}
public synchronized boolean deduct() {
if (stock <= 0) {
return false;
}
stock--;
return true;
}
public synchronized int remaining() {
return stock;
}
}这里假设构造参数非负,且库存只通过类中展示的方法访问。实例方法上的 synchronized 使用当前对象 this 作为锁;多个线程必须调用同一个库存实例,才能由同一把锁协调。
**临界区(Critical Section)**是访问共享状态、需要协调并发访问的一段代码。这里把“检查库存与扣减库存”放在同一个受锁保护的临界区:A 检查通过后,B 必须等 A 完成扣减并释放锁,才能重新检查库存。只给 stock-- 加锁,无法保护前面的检查结果。
同一个对象上的 synchronized 还提供两项关键保证:
- 同一时刻最多只有一个线程进入受同一把锁保护的临界区;
- 一个线程释放锁之前的写入,对后续获得同一把锁的线程可见。
读取方法同样加锁并不是多余的。如果写入受锁保护,读取却绕过锁,那么类的同步策略就不完整。虽然读取单个 int 本身具有原子性,但调用者还需要可靠地观察到最新状态。
5.1 锁对象必须稳定且私有
不推荐这样写:
java
private String lock = "inventory";
public void deduct() {
synchronized (lock) {
// ...
}
}字符串驻留(String Interning)会让相同内容的字符串共享同一个对象;这里的字符串字面量就可能被无关代码共同使用。锁按对象身份区分,因此无关代码可能意外争用同一把锁。如果 lock 被重新赋值,不同线程还可能锁住不同对象,使互斥失效。
更稳妥的写法是:
java
private final Object lock = new Object();将专用锁对象设为 private final,并且不向外暴露它,可以避免外部代码意外使用这把锁,也保证锁的身份不变。前面的实例方法使用 this,仍然能提供互斥,但持有该实例的外部代码也能在它上面加锁;专用私有锁用于减少这种干扰。
6. 正例二:用 CAS 实现单变量的条件更新
如果业务不变量只涉及一个整数,可以使用原子整数类 AtomicInteger 的 CAS(Compare-And-Set,比较并设置)。它将“比较当前值是否等于预期值”和“相等时写入新值”合成一次原子操作。比较失败时不更新,调用方需要重新读取并判断。
java
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicInventory {
private final AtomicInteger stock;
public AtomicInventory(int stock) {
this.stock = new AtomicInteger(stock);
}
public boolean deduct() {
while (true) {
int current = stock.get();
if (current <= 0) {
return false;
}
// 只有 stock 仍等于 current 时才更新为 current - 1
if (stock.compareAndSet(current, current - 1)) {
return true;
}
// 更新失败说明其他线程已修改库存,重新读取后再试
}
}
public int remaining() {
return stock.get();
}
}同样假设初始库存非负,且只有示例中的扣减会修改它。如果 A、B 都读到 1,只有一次 CAS 能把 1 改成 0;另一次比较失败,重新读取 0 后返回 false。这样就把检查时的值和真正更新时的值联系起来,避免使用失效的检查结果。
成功的 compareAndSet 是本例成功扣减的线性化点:虽然方法经历了读取、判断和重试,但可以把成功操作视为在这一瞬间完成。选择保护方式时,要能指出业务状态究竟在哪一步生效。
CAS 方案没有使用互斥锁,但不等于“永远更快”。高竞争下,大量线程可能不断重试,消耗 CPU。具体性能受 JDK 版本、CPU 架构、线程数和临界区工作量影响,必须使用 JMH(Java 微基准测试工具)或真实负载压测,不能只凭 API 名称下结论。
6.1 多个原子变量不等于组合操作原子
如果一次扣减还要同时修改“已售数量”和“库存版本”,把三个字段都改成原子类,也不能自动保证三者作为整体的原子性。库存更新后、已售数量更新前,其他线程仍可能读到不匹配的组合。这时可以:
- 用同一把锁保护所有相关状态;
- 把多个字段封装成不可变对象,通过一个
AtomicReference整体替换; - 将一致性下沉到具有事务或条件更新能力的存储层。
AtomicReference 是原子引用类:更新者构造包含多个字段的完整新状态,再通过 CAS 整体替换引用;读者取得同一个不可变状态对象,避免读到拆开的字段组合。数据库事务则把一组存储操作组织为一个提交或回滚的整体,具体隔离保证仍取决于数据库和隔离级别。
7. 生产环境:单 JVM 的锁管不住多实例
前面的 synchronized 和 AtomicInteger 只能协调同一 JVM 进程内的线程。如果服务部署了多个实例,每个实例都有自己的内存和锁,就不能依靠本地锁保护数据库中的全局库存。
关系型数据库中,一种常见方案是条件更新:把“库存大于 0”的检查放进更新语句,让所有实例通过同一份数据库记录竞争,而不是先把库存读到各自内存再判断。下面是使用 ? 参数占位符的 SQL 片段,需要由数据库驱动绑定商品编号;影响行数的判断以 product_id 唯一标识一条库存记录为前提。
sql
UPDATE product_stock
SET stock = stock - 1
WHERE product_id = ?
AND stock > 0;应用必须检查影响行数:
- 影响 1 行:扣减成功;
- 影响 0 行:库存不足或商品不存在。
还要处理执行失败和事务回滚:影响 1 行表示语句完成了扣减,不等于整个下单事务已经提交。
该语句的并发行为还受数据库类型、存储引擎、事务隔离级别和索引设计影响。对 MySQL InnoDB 而言,生产上仍需在目标版本和实际表结构下验证锁范围与吞吐表现,不应把一条 SQL 当成无条件适用的秒杀方案。
这里的条件更新是“依赖共享存储的原子状态转移”,不是把 JVM 锁替换成 Redis 锁。需要跨进程互斥时,还必须处理租约过期后的旧持有者,详见 分布式 30 - Redis 分布式锁与 Fencing。数据库锁和隔离级别的语义分别见 数据库 19 - SELECT 与锁和 数据库 17 - 事务隔离级别。
8. 三种从根上降低并发风险的方法
8.1 不变性:能不改,就不共享可变状态
不可变对象创建后不再修改,多线程只读时通常不需要互斥。
java
public final class PriceRule {
private final long productId;
private final int discount;
public PriceRule(long productId, int discount) {
this.productId = productId;
this.discount = discount;
}
public long getProductId() { return productId; }
public int getDiscount() { return discount; }
}不可变性并不意味着“所有字段加 final 就完事”;如果字段引用了可变集合,还需要防止集合被外部修改。
8.2 线程封闭:不让状态跨线程
线程封闭指一份可变状态只由一个线程访问,不需要与其他线程协调。方法内的局部变量属于当前调用栈,但变量指向的对象不一定只属于当前线程:参数可能指向共享对象,局部引用也可能被传给其他线程。只有对象没有被其他线程共享访问时,才能据此无锁修改。
常见风险是把局部对象放入全局缓存、回调、线程池任务或静态字段,使它从“线程封闭”变成“共享可变”。
8.3 同步:共享且必须可变时,建立单一协调策略
同步不只是加锁,还包括 CAS、并发容器提供的原子方法、消息串行化和数据库事务等。关键是:
所有访问同一组不变量的代码,必须遵守同一套协调协议。
如果 9 个方法都正确加锁,第 10 个方法绕过了锁,整个类仍然不是线程安全的。
9. 容易踩的坑
9.1 坑:“没有复现”就等于“没有问题”
并发错误可能只在特定 CPU 核数、JIT(即时编译)状态和负载下出现。审查时应从共享状态和同步协议证明正确性。后续文章会用 happens-before 关系检查写入到读取之间的可见性保证;它不是单纯按时钟比较谁先执行。
9.2 坑:对象放进 ConcurrentHashMap 就安全了
ConcurrentHashMap 是线程安全的键值容器,保护的是容器自身的结构与特定原子方法,不会自动保护值对象内部的可变字段。例如,把库存对象放进容器后,多个线程取得的仍可能是同一个对象,调用它的 deduct() 仍需遵守该对象的同步策略。
9.3 坑:锁范围越大越安全
大锁范围往往更容易证明正确性,但可能降低并发度,甚至把网络请求、磁盘 I/O 也包含在临界区内。正确做法是先确保不变量完整,再通过度量缩小锁范围,而不是为了性能先拆碎同步边界。
9.4 坑:本地锁能保护集群数据
synchronized 和 ReentrantLock 都只对当前 JVM 生效。集群环境需要依赖数据库、分布式锁、唯一约束或消息串行化等跨进程协调机制。具体选型取决于业务一致性、吞吐与可用性要求。
10. 进阶:如何选择保护方式
| 场景 | 优先考虑 | 注意点 |
|---|---|---|
| 不需要修改的配置、值对象 | 不可变对象 | 注意可变成员的防御性拷贝 |
| 仅在单个线程内使用 | 线程封闭 | 不要意外发布引用 |
| 单 JVM、多状态组合不变量 | synchronized / Lock | 所有读写统一遵守锁协议 |
| 单 JVM、单变量简单更新 | 原子类 / CAS | 高竞争时留意重试开销 |
| 并发集合操作 | 并发容器原子 API | 容器安全不等于 Value 安全 |
| 多实例修改全局库存 | 数据库条件更新/事务 | 检查影响行数,验证锁与索引 |
性能优化的顺序应该是:先定义正确性,再建立可观测指标,最后用数据优化。一段答案错了的并发代码,跑得越快,只会越快地制造脏数据。
11. 面试快问快答
volatile int count 的 count++ 是线程安全的吗?
不是。volatile 保证可见性和一定的有序性,count++ 是读-改-写复合操作,仍会丢失更新。
单个 int 的读写是原子的,为什么还会出问题?
因为业务操作通常不只是单次读或写,而是依赖旧值的复合操作。单步原子不等于组合原子。
AtomicInteger 一定比 synchronized 快吗?
不一定。低竞争、短操作下 CAS 可能有优势;高竞争下可能因反复重试消耗 CPU。实际结果必须在相同负载和环境下压测。
什么是线程安全的核心?
在并发访问下,对象仍能维持它的业务不变量,且不要求调用者了解其内部实现后额外协调。
12. 总结
并发安全的核心不是给变量加关键字,而是找到业务不变量,并用一致的协调策略保护它。
可带走的三个要点:
- 共享、可变、复合操作同时出现时,就要警惕竞态条件。
volatile不能修复读-改-写的原子性问题;锁或 CAS 必须覆盖完整不变量。- JVM 内的线程安全不等于分布式一致性,多实例库存应由共享存储层提供原子约束。
阅读导航
- 下一步:02 - Java 线程生命周期与正确中断方式
- 可见性与发布:03 - JMM 与 happens-before
- 互斥实现:04 - synchronized 的 Monitor 机制
- 无锁更新:07 - CAS 与原子类
- 并发容器:08 - ConcurrentHashMap 与并发容器
- 正确性验证:A - Java 并发代码测试方法
- 状态所有权:28 - 单写者模型与消息传递