悲观锁:使用数据库悲观锁保证一致性

问题:50万人抢100台手机,如何保证不超卖?😰

想象一下这个场景:

秒杀开始:

  • 库存:100台iPhone
  • 参与用户:50万人
  • 并发请求:瞬间涌入50万次
  • 你的任务:保证不多卖一台,不少卖一台

传统方案的问题:

超卖现象演示:

时间线:
T1: 线程A读取库存 = 1
T2: 线程B读取库存 = 1  ← 都看到还有1台
T3: 线程A判断库存充足,下单
T4: 线程B判断库存充足,下单  ← 都认为可以买
T5: 线程A扣减库存:stock = 0
T6: 线程B扣减库存:stock = -1  ← 超卖了!

结果:库存1台,卖出2台,超卖!

解决方案:悲观锁 🔒

悲观锁的核心思想:假设冲突一定会发生,操作前先加锁。

数据库悲观锁的实现

数据设计要点

  • 查询目标是快速定位状态、任务或资源,避免在关键路径上做大范围扫描。

完整方案落地:

并发测试:验证悲观锁的正确性

测试输出:

🚀 开始并发测试:20个用户同时抢购

============================================================
🔒 用户1尝试获取商品1的锁...
✅ 用户1获得锁,当前库存:10
🔒 用户2尝试获取商品1的锁...  ← 等待中...
🔒 用户3尝试获取商品1的锁...  ← 等待中...
...
🎉 用户1购买成功,剩余库存:9
✅ 用户2获得锁,当前库存:9
🎉 用户2购买成功,剩余库存:8
✅ 用户3获得锁,当前库存:8
...
❌ 用户11:库存不足,stock=0
❌ 用户12:库存不足,stock=0
...

============================================================
📊 测试结果:
  总请求数:20
  成功数:10
  失败数:10
  耗时:245.32ms
  平均响应时间:12.27ms

悲观锁的工作原理 🔍

让我们深入理解悲观锁的底层机制:

悲观锁的核心思想是”我先锁上,你等会儿”。在关系型数据库里,这个”锁”由存储引擎在 InnoDB 的行锁上实现,触发方式有两种:显式加锁和隐式加锁。

显式加锁是秒杀里用得最多的 SELECT ... FOR UPDATE:

BEGIN;
-- 命中主键索引时,InnoDB 对这一行加排他锁(X Lock)
SELECT stock FROM product WHERE id = 1001 FOR UPDATE;

-- 其他事务的同一条语句会在这里阻塞,直到上面的事务提交或回滚

这里的机制细节决定了很多实践要点:

  1. 锁是加在索引上的,不是加在数据行上的。 WHERE id = 1001 命中主键索引时,锁的粒度是这一行;如果条件没走索引(比如 WHERE name = 'iPhone'),InnoDB 只能锁住扫描到的所有行乃至整张表——这就是为什么锁查询必须命中索引。
  2. 加锁与读的区别在于”是否排他”。 普通 SELECT 是共享读(S Lock),多个读可以并存;FOR UPDATE 是排他锁,一旦某个事务持有,其他事务连读都要等。写路径上的库存查询必须用 FOR UPDATE(或直接用条件更新),否则读到的还是旧值。
  3. 锁在事务提交时释放。 这意味着”锁的持有时长 = 事务时长”,任何在事务里做的慢操作都会变成全局的串行点。
  4. 间隙锁与死锁。 在可重复读隔离级别下,范围查询会额外加间隙锁,锁住”记录之间的空隙”,防止幻读。这提升了正确性,但也让多行按不同顺序加锁的事务更容易互相等待,形成死锁——所以多商品场景必须按主键升序加锁。

隐式加锁指的是数据库在执行 UPDATE / DELETE 时自动加的行锁。所以还有一条更省事的等效写法:

-- 不需要显式 FOR UPDATE:条件更新本身就带行锁,且判断与扣减在同一条语句里原子完成
UPDATE product SET stock = stock - 1 WHERE id = 1001 AND stock >= 1;

这条语句同时解决了两个问题:行锁保证并发串行,AND stock >= 1 保证扣减不会把库存扣成负数。即使应用层漏判了库存,affected_rows = 0 也能告诉调用方”没抢到”。

实现层次上的选择也值得说清楚:悲观锁并不一定要落在数据库上。MySQL 的 SELECT ... FOR UPDATE、PostgreSQL 的 SELECT ... FOR UPDATE、以及基于 Redis 的 SETNX/WATCH 乐观锁模拟,都能在不同层面提供”互斥”语义。区别在于粒度和代价:数据库行锁的粒度精确到行、开销可接受,但吞吐上限只有 1000-5000 QPS;Redis 的单线程原子操作能到 10 万 QPS 量级,代价是数据在内存里、丢一次就要靠对账或落库兜底。

悲观锁的优缺点分析

优点 ✅

优点说明适用场景
强一致行锁 + 事务保证读到的就是最新值,天然不会超卖资金、库存等不能妥协的场景
无 ABA 问题持锁期间别人改不了,值不可能”改了又改回来”版本号/CAS 不适用的场景
先到先得,公平排队顺序由锁的获取顺序决定,符合用户直觉需要公平性的场景
实现简单一条 SQL,数据库保证正确性,不依赖应用层逻辑团队没有高并发经验时
无冲突重试不存在”白做一次再重试”,失败就是明确失败需要确定性结果的场景

悲观锁的价值不在秒杀,而在”并发量不高,但绝对不能错”的那些场景:后台库存调整、账户余额扣减、优惠券核销、库存盘点对账、订单状态机流转。

在普通电商里(日并发几千、库存充足),悲观锁的强一致性本身就是一种价值——它让业务代码不必处理”扣减可能失败”的重试逻辑,心智负担最小。

缺点 ❌

缺点说明影响
吞吐上限低同一行只能串行,实测 1000-5000 QPS与 50 万 QPS 差 100-500 倍
持锁时间放大风险事务里任何慢操作(RPC、日志、调用外部接口)都会拉长锁的持有时间一次超时可能拖垮整条链路
连接池被占满等待锁的请求同样占用连接1000 个请求就能打满 100 连接池,引发雪崩式超时
死锁风险多个事务以不同顺序更新多行时会互相等待需要死锁检测 + 重试,增加复杂度
读写分离失效锁只能加在主库,读走从库的方案无法用于写路径架构复杂度上升
排队放大锁等待时间远大于接口超时时间用户拿到的是”超时”,而不是”库存不足”这种可行动的明确失败

其中最容易被低估的是持锁时间。悲观锁的吞吐上限不只是”1/事务耗时”,而是”1/持锁时间”——持锁时间越长,队列排得越慢,连接池越容易被占满。而且持锁时间会被任何一次网络抖动放大:

理想情况:事务 3 条 SQL,10ms 持锁 → 100 TPS/连接 ✅
事故现场:事务里调了一次 RPC(超时 2s)→ 200 TPS/连接直接掉到 5
           → 连接池 100 个被 5 个慢请求占住 → 全站超时 ❌

锁持有时间是最容易被”加一行日志”破坏的指标。

性能对比表

并发量悲观锁表现平均响应时间数据库负载用户体验
100✅ 优秀10ms20%⭐⭐⭐⭐⭐
500✅ 良好50ms40%⭐⭐⭐⭐
1000✅ 可接受100ms60%⭐⭐⭐
2000⚠️ 一般200ms80%⭐⭐
5000⚠️ 较慢500ms95%⭐
10000+❌ 不可用1s+100%崩溃 💥

最佳实践建议 💡

如果确实要用悲观锁(比如消费端兜底、后台管理系统),下面几条能避免绝大多数事故:

1. 缩小事务边界

锁只包住”扣库存 + 写订单”这几条 SQL,发消息、记日志、推送通知、调用外部接口一律移到事务外:

BEGIN;
-- 命中主键索引,锁粒度 = 1 行
SELECT stock FROM product WHERE id = ? FOR UPDATE;
-- 条件更新:即使锁语义被绕过,也不会超卖
UPDATE product SET stock = stock - 1 WHERE id = ? AND stock >= 1;
-- 订单号唯一索引做幂等键
INSERT INTO orders (order_id, user_id, product_id, quantity, status)
VALUES (?, ?, ?, 1, 'PENDING');
COMMIT;

-- 事务外:发 MQ、记日志、推通知

2. 控制事务内的语句数量

事务内 SQL 控制在 3 条以内。每多一条 SQL,持锁时间就多一份不确定性。

3. 保证锁粒度最小

  • 条件里必须带主键或唯一索引命中,否则可能锁住全表或一大片行;
  • 多商品场景按商品 ID 升序依次加锁,避免交叉持锁造成死锁;
  • 不要用 SELECT * 带上无关字段,更不要在锁内做联表。

4. 超时参数必须和接口对齐

innodb_lock_wait_timeout 的默认值是 50 秒,远大于接口超时时间。正确做法是让它小于接口超时:

接口超时 3s → innodb_lock_wait_timeout = 1s

这样等待超过 1 秒的请求会快速失败,拿到明确的”库存不足/系统繁忙”,而不是干等 3 秒后超时。快速失败比慢慢排队好得多——秒杀的库存本来就只有 100 件,让 50 万个请求排成一列没有意义。

5. 必须有条件更新兜底

WHERE stock >= ? 这一行不能省。即使锁因为任何原因失效了,条件更新依然能挡住超卖。锁是第一道防线,条件更新是第二道,两道都要有。

6. 锁不是解决方案,是限制器

真正的解法是把并发降下来:限流、排队、Redis 预扣、队列串行化。秒杀链路里,悲观锁的正确位置是”消费端的兜底”,而不是”入口的主方案”——入口用 Redis 挡掉 99.98% 的无效请求之后,真正到达数据库的写只有 100 次,那时候用不用锁都无所谓。

7. 锁指标要上看板

锁等待次数、锁等待时长、锁超时次数、死锁次数,这四个指标必须和 QPS 放在一起看。锁等待时长一旦上涨,往往比 QPS 更早预示问题。

想一想

问题 1:悲观锁能支撑多少QPS?

根据我们的测试和经验数据:

  • 单机MySQL:最多支撑 1000-5000 QPS
  • 主从架构:悲观锁只能走主库,无法分担压力
  • 秒杀场景:50万QPS远远超出能力范围

你的思考:如果秒杀QPS是50万,悲观锁够用吗?

问题 2:如何优化悲观锁性能?

提示方向:

  • 能否减少锁的粒度?(行锁 vs 表锁)
  • 能否缩短事务时间?
  • 能否用缓存分担压力?

问题 3:什么场景适合用悲观锁?

考虑因素:

  • 并发量级
  • 一致性要求
  • 开发成本
  • 系统复杂度

发现内容有问题?

告诉我们哪里需要改进。