防超卖:防止库存超卖的核心方案
翻回到第 2 章的那个场景:库存 100 台 iPhone,50 万人抢。
目标:100 台机器,一台都不能多卖。
现实:某天运营收到反馈,有用户买到了第 101 台。
超卖是秒杀系统最不能接受的故障。少卖只是少赚;超卖是把同一台货卖给了两个人——要么退款赔钱,要么只能给其中一人补偿,两种做法都直接伤害用户对平台的信任。
这一章要把前面所有章节的能力收拢起来,给出防超卖的完整方案。
先说清楚超卖是怎么发生的。翻遍各种原因,其实只有三个源头:
源头 1:并发扣减本身不原子
100 个请求同时读到库存=100,都判断"够",都扣减 → 卖出 100 台以上
源头 2:跨系统状态不一致
Redis 扣了 100,MySQL 因为故障只扣了 99 → 用 100 的名额发了 101 单
源头 3:释放与补偿逻辑出错
超时订单释放了库存,但释放执行了两次 → 多出 1 件可售
三个源头需要三道防线,缺一不可。 任何一道防线单独用都不够。
第一道防线:Redis 原子扣减
这是 4.1 节用过的方案,作用是让”判断库存”和”扣减库存”成为一个不可分割的原子操作。
❌ 有竞态的写法:
if (GET stock) > 0:
DECR stock
→ 100 个请求可能同时通过判断
✅ 原子的写法:
Lua 脚本一次完成:判断 + 扣减 + 返回结果
→ Redis 单线程执行脚本,天然互斥
这道防线挡住的是源头 1。它的能力边界也要说清楚:
- ✅ 挡住:单实例 Redis 内部的并发扣减竞态
- ❌ 挡不住:Redis 集群跨节点、Redis 故障后的数据丢失、Redis 与 MySQL 之间的不一致
所以还需要后两道。
第二道防线:数据库条件更新
即使 Redis 侧保证了不超卖,MySQL 侧也必须自己再挡一次。
UPDATE product
SET stock = stock - ?
WHERE id = ? AND stock >= ?
关键在 stock >= ? 这个条件。它把”检查”和”更新”合并进了同一条语句,由数据库的行锁保证原子性。
条件不满足 → 影响行数为 0 → 扣减失败 → 走回滚/释放流程
条件满足 → 影响行数为 1 → 扣减成功
为什么两道防线都要有:Redis 和 MySQL 是两个独立系统,中间隔着消息队列。只要有一次同步失败、一次消息丢失、一次补偿出错,两边的库存就会对不上。如果 MySQL 侧也有一道条件更新,那么即使 Redis 侧出了问题,货依然发不出去。
Redis 多扣了 1 → MySQL 扣减时 stock >= 1 不满足 → 扣减失败 → 订单不成立
这条防线是最后一道闸门,它必须独立成立。 任何依赖”上游一定是对的”的防线,在生产环境都会漏。
第三道防线:对账与止损
前两道防线都是”事前”拦截。如果两道都因为某种未知原因失效了(Bug、配置错误、故障叠加),还需要一道”事后”防线:
对账发现超卖
↓
立即停止放量(关闭活动 / 限制继续下单)
↓
人工处理:确定哪一单作废、退款或补偿
↓
复盘根因,修掉真正的漏洞
止损比修复更重要。超卖一旦发现还在继续放量,损失会随着时间线性增长。先止血,再复盘——这是第 6.2 节那一页的核心。
三道防线的分工
| 防线 | 位置 | 时机 | 挡住的源头 |
|---|---|---|---|
| Redis 原子扣减 | 入口 | 事前 | 源头 1:并发竞态 |
| MySQL 条件更新 | 消费端 | 事中 | 源头 2:跨系统不一致 |
| 对账与止损 | 离线 | 事后 | 源头 3:释放/补偿出错 |
三道防线的可靠性是递减的——越往后越不可靠,但越往后越能兜住前面漏掉的问题。所以真正的方案是三层叠加,不是三选一。
第一道防线具体怎么落地,就是 Lua 脚本。
为什么必须是 Lua
Redis 的单条命令是原子的,但多条命令组合起来不是:
❌ 分两步:
stock = GET stock_key
if stock > 0 then
DECR stock_key
end
→ GET 和 DECR 之间有间隙,别的请求能插进来
✅ 一步:
EVALSHA script_sha 1 stock_key 1
→ 整个脚本作为一个原子单元执行
Redis 执行脚本期间不会处理其他命令,所以脚本里的判断和扣减不会被插队。
脚本实现
-- deduct.lua
-- KEYS[1]: 库存 key
-- ARGV[1]: 扣减数量
-- 返回: 1 = 成功, 0 = 库存不足, -1 = key 不存在
local stock = redis.call('GET', KEYS[1])
if not stock then
return -1
end
if tonumber(stock) < tonumber(ARGV[1]) then
return 0
end
local remaining = redis.call('DECRBY', KEYS[1], ARGV[1])
return 1
这个脚本做了三件事:取库存、判断是否足够、扣减。三件事在同一个原子单元里,没有中间态。
调用方式
import redis
# 预加载并缓存 SHA,后续用 EVALSHA 调用,省去每次传输脚本体
deduct_sha = r.script_load(DEDUCT_SCRIPT)
def try_deduct(stock_key: str, quantity: int) -> bool:
try:
result = r.evalsha(deduct_sha, 1, stock_key, quantity)
except redis.exceptions.NoScriptError:
# 脚本被 flush 或重启了,重新加载
deduct_sha = r.script_load(DEDUCT_SCRIPT)
result = r.evalsha(deduct_sha, 1, stock_key, quantity)
if result == 1:
return True
elif result == 0:
return False
else:
raise RuntimeError(f"库存 key 不存在: {stock_key}")
用 EVALSHA 而不是 EVAL:脚本体传输一次后,后续只传 SHA 值,网络开销小得多。代价是要处理 NoScriptError——Redis 重启或 SCRIPT FLUSH 后 SHA 会失效,这时重新加载一次即可。
加上限流更稳
脚本内部顺便做一次用户维度的检查,能挡住刷子:
-- 同一用户限一次
local bought = redis.call('GET', KEYS[2])
if bought then
return -2 -- 该用户已抢过
end
-- ... 库存判断与扣减 ...
redis.call('SET', KEYS[2], 1, 'EX', 3600)
return 1
返回码要设计得能区分失败原因。只返回 0/1 的话,调用方分不清”库存不足”和”重复提交”,处理逻辑会写错。
防线的最后还要有检测——不能等到用户投诉才知道超卖了。
实时检测
每个订单创建后,立刻校验一次:
MySQL 实际已售量 <= 初始库存?
├─ 是 → 正常
└─ 否 → 超卖!立即告警 + 停止放量
这个校验可以放在消费者端,每处理一个订单就查一次累计已售量。开销不大(一次计数查询),但能在超卖发生的第一时间就发现。
更轻量的做法:在 Redis 侧维护一个累计售出计数器,扣减时同步 INCR,这个计数器超过初始库存就说明出问题了。
主动巡检
除了被动等告警,还要有主动巡检:
定时(秒级/分钟级):
对比 Redis 已扣减总量 与 MySQL 已售量
对比 MySQL 已售量 与 初始库存
任何一项异常 → 告警
这和第 6.2 节的对账是同一套机制的两个频率档位——对账是分钟级批量的,实时检测是秒级单点的。
告警要带上下文
一条有用的超卖告警应该包含:
活动 ID、商品 ID、初始库存
Redis 当前值、MySQL 已售量、已支付订单数
差异量、受影响的订单号列表
发生时间、活动放量比例
只有”超卖了”三个字的告警等于没有告警。值班同学需要能直接看到是哪个活动、哪个商品、差多少、哪些订单,才能快速决策。
止损开关
检测到异常后要能快速止损:
分级开关:
关闭活动 → 立即停止所有下单
限制放量 → 只允许已购用户操作(如查订单、退款)
限制商品 → 只停问题商品,其他商品继续
分级很重要。发现一个商品有问题就关掉整场活动,代价太大;直接全站停服更不可接受。
- 超卖有三个源头:并发扣减不原子、跨系统状态不一致、释放补偿出错。三道防线分别对应。
- Redis 原子扣减挡并发竞态,用 Lua 把判断和扣减合成一个原子单元。
- MySQL 条件更新是最后一道闸门,必须独立成立,不能假设上游一定是对的。
- 对账与止损是事后防线,先止血再复盘,别让损失继续扩大。
- Lua 脚本用
EVALSHA调用,并处理NoScriptError重新加载。 - 返回码要能区分失败原因,否则调用方的处理逻辑会写错。
- 检测要主动:实时校验 + 定时巡检,不能等用户投诉。
- 告警必须带上下文,止损开关要分级。
至此,第 6 章讲完了库存的一致性与超卖防线。下一章转向另一个维度——反作弊。黄牛和脚本农场同样会破坏秒杀活动的公平性,而它们的攻击面和防超卖完全不同。
问题 1:Redis 扣减成功但消息发送失败,MySQL 的条件更新还拦得住吗?
解题思路:
这题最容易犯的错是把”库存少了”直接当成”超卖”。正确的做法是先把链路完整推演一遍,看 MySQL 那条条件更新到底有没有被调用过——如果根本没调用,就谈不上拦截;再判断数量关系:实际卖出的件数有没有超过真实库存。
详细步骤:
拦不住——但这个场景其实不是超卖,而是少卖。
推演一遍:
Redis 扣减成功(库存 100 → 99)
↓
发消息失败 ❌ → 消费者从未被触发
↓
MySQL 侧:没有订单产生,UPDATE stock ... WHERE stock >= 1 根本没执行
↓
MySQL 库存仍然是 100MySQL 的条件更新压根没被调用过,所以谈不上”拦不拦得住”。条件更新防的是”条件不满足却仍要写入”,而这里根本没有写入动作。
结果是少卖,不是超卖:
Redis 可售库存:99
MySQL 真实库存:100Redis 少了 1 件可售,MySQL 一件没卖。实际卖出的数量没有超过真实库存,所以不存在超卖。 用户少抢到 1 件,是可售量被虚占导致的。
这属于”库存泄漏”:库存被预扣却永远不会变成订单,货还在,只是暂时卖不出去。
正确的处理是补偿,而不是防超卖:
没有订单 → 没有占用 → 直接把 Redis 库存补回 1这正是第 6.2 节对账任务处理的场景——扫描出 Redis 已扣减总量与 MySQL 占用 + 已售之间的差额,把差额补回。
如果消息没有丢失,只是延迟了,那就什么都不用做——消费者迟早会消费到,MySQL 库存会正常扣减,最终两边一致。
最终答案:
MySQL 条件更新在这个场景中不会被触发;问题性质是少卖(库存泄漏)而非超卖,靠对账补回库存即可。
问题 2:两道防线的判断逻辑是重复的,为什么不能只留一道?
解题思路:
表面上两道防线都在判断”库存够不够”,像是重复劳动。判据是它们各自依赖什么假设、以及假设不成立时故障往哪个方向偏。把”Redis 多扣 1 件”这一个场景分别代入两种配置推演,就能看出两者防的是相反方向的故障。
详细步骤:
两道的判断逻辑看着重复,但它们依赖的假设完全不同。 这正是”纵深防御”的意义。
各自依赖什么:
| 防线 | 依赖的假设 | 假设不成立时 |
|---|---|---|
| Redis 原子扣减 | Redis 永远可靠地执行了脚本,且 Redis 里的库存值是可信的 | Redis 故障、集群脑裂、脚本未执行、Redis 数据丢失 → 扣减数超发 |
| MySQL 条件更新 | 每次”应该扣库存”的动作都最终走到了这条 SQL | 消息丢失、消费者崩溃、订单创建失败 → 扣减数少发(少卖) |
关键洞察:两道防线防的是相反方向的故障。
Redis 侧超发(扣多了)→ MySQL 条件更新挡住 → 结果是少卖,不是超卖 ✅
MySQL 侧少发(扣少了)→ Redis 已经扣过了 → 结果是少卖 ✅只看”Redis 和 MySQL 不一致”这一个场景:
假设 Redis 多扣了 1(该卖 100 件,Redis 认为能卖 101):
Redis 预扣:101 件
MySQL 实际卖出:100 件- 只有 Redis 防线:MySQL 没有条件更新,100 件的货被卖了 101 单 → 超卖 ❌
- 只有 MySQL 防线:Redis 预扣 101 件的消息有 101 条,MySQL 第 101 次执行
UPDATE ... WHERE stock >= 1时库存已为 0,条件不满足,扣减失败 → 第 101 单不成立 ✅
所以 MySQL 条件更新恰好是 Redis 防线失效时的兜底。
再看你说的”重复”:
表面上看,两道防线都在判断”库存够不够”。但它们服务的目标不同:
- Redis 那一层的目标是性能——在 50 万 QPS 下快速筛掉绝大多数无效请求,绝不能有同步开销。
- MySQL 那一层的目标是正确性——在低得多的 QPS 下做最后确认,代价可以承受。
它们不是重复劳动,而是用便宜的方式挡掉 99.9%,用贵的方式确认剩下的 0.1%。如果只有 MySQL 一道,50 万 QPS 会直接压垮数据库;如果只有 Redis 一道,Redis 一旦出问题就没有兜底。
最终答案:
两道的判断逻辑不重复——它们依赖的前提不同、防的是相反方向的故障、服务的目标不同(性能 vs 正确性)。MySQL 条件更新正是 Redis 防线失效时的兜底,少一道就少一层保障。
问题 3:如果把 MySQL 的 stock >= 1 去掉,系统的行为会有什么变化?
解题思路:
先确认去掉这个条件改变了什么、没改变什么。并发扣减本身不会因此丢失更新(行锁仍在),所以”少卖”不会变严重;真正改变的是”库存不足时数据库还会不会拒绝写入”——这决定了不一致场景下到底是超卖,还是仅仅数据变得难看。
详细步骤:
最直接的变化:系统退化成”只有一道防线”,超卖重新变成可能。
去掉之后的 SQL:
-- 改前
UPDATE product SET stock = stock - ? WHERE id = ? AND stock >= ?
-- 改后
UPDATE product SET stock = stock - ? WHERE id = ?改后仍然有行锁保护,并发扣减本身不会丢失更新(两个并发 UPDATE 会串行执行,第二个读到的是第一个改完的值)。所以”少卖”这类问题不会变严重。
真正的变化在 Redis 与 MySQL 不一致的场景:
场景:Redis 多扣了 1(预扣 101 件,真实只有 100 件)
↓
第 101 条消息到达消费者
↓
改后:UPDATE product SET stock = stock - 1 WHERE id = ?
→ 库存 0 - 1 = -1,不报错,扣减"成功"!
→ 订单创建成功
→ 货只有 100 件,却卖了 101 单 → 超卖 ❌这就是 stock >= ? 的全部价值:它把”库存不足”从一次数据损坏,变成一次正常的业务失败。
没有这个条件,数据库不会阻止扣减,它只会老老实实地把库存扣成负数。数据库不是业务规则的执行者,它是最后一道闸门——这道闸门要自己判断,不能指望上游永远正确。
还有两个附带影响:
- 库存为负数。改后可能出现
stock = -1的数据,之后所有基于库存的判断(“还有货吗”)都要额外处理负数,而且对账公式也会失真。 - 失去自诊断能力。改后扣减成功,链路一路绿灯,没有任何环节会发现异常——直到用户投诉。而改前的失败是”响亮”的:扣减失败 → 走释放流程 → 订单不成立 → 用户收到”未抢到”。
什么时候可以去掉:
如果能严格保证”Redis 扣减数永远等于 MySQL 扣减数”,那这个条件确实是冗余的。但”永远保证”本身就需要一整套机制(可靠消息、幂等、对账)——而这整套机制在故障时正是最可能失效的。在一个本可以用来兜底的检查上省一次 WHERE 判断,收益极小,代价是丢掉最后一道防线。
最终答案:
去掉后超卖会重新成为可能——Redis 一旦多扣,MySQL 会把库存扣成负数并创建成功订单。同时会失去库存非负的约束和故障自诊断能力。这个条件是最后一道闸门,不应去掉。
发现内容有问题?
告诉我们哪里需要改进。
