防超卖:防止库存超卖的核心方案

问题:库存100件,卖出101件怎么办?😱

翻回到第 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 脚本。

为什么必须是 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 已售量、已支付订单数
差异量、受影响的订单号列表
发生时间、活动放量比例

只有”超卖了”三个字的告警等于没有告警。值班同学需要能直接看到是哪个活动、哪个商品、差多少、哪些订单,才能快速决策。

止损开关

检测到异常后要能快速止损:

分级开关:
  关闭活动 → 立即停止所有下单
  限制放量 → 只允许已购用户操作(如查订单、退款)
  限制商品 → 只停问题商品,其他商品继续

分级很重要。发现一个商品有问题就关掉整场活动,代价太大;直接全站停服更不可接受。

阶段小结

  1. 超卖有三个源头:并发扣减不原子、跨系统状态不一致、释放补偿出错。三道防线分别对应。
  2. Redis 原子扣减挡并发竞态,用 Lua 把判断和扣减合成一个原子单元。
  3. MySQL 条件更新是最后一道闸门,必须独立成立,不能假设上游一定是对的。
  4. 对账与止损是事后防线,先止血再复盘,别让损失继续扩大。
  5. Lua 脚本用 EVALSHA 调用,并处理 NoScriptError 重新加载。
  6. 返回码要能区分失败原因,否则调用方的处理逻辑会写错。
  7. 检测要主动:实时校验 + 定时巡检,不能等用户投诉。
  8. 告警必须带上下文,止损开关要分级。

至此,第 6 章讲完了库存的一致性与超卖防线。下一章转向另一个维度——反作弊。黄牛和脚本农场同样会破坏秒杀活动的公平性,而它们的攻击面和防超卖完全不同。

想一想

问题 1:Redis 扣减成功但消息发送失败,MySQL 的条件更新还拦得住吗?

防超卖消息队列库存补偿

解题思路:

这题最容易犯的错是把”库存少了”直接当成”超卖”。正确的做法是先把链路完整推演一遍,看 MySQL 那条条件更新到底有没有被调用过——如果根本没调用,就谈不上拦截;再判断数量关系:实际卖出的件数有没有超过真实库存。

详细步骤:

拦不住——但这个场景其实不是超卖,而是少卖。

推演一遍:

Redis 扣减成功(库存 100 → 99)
  ↓
发消息失败 ❌  →  消费者从未被触发
  ↓
MySQL 侧:没有订单产生,UPDATE stock ... WHERE stock >= 1 根本没执行
  ↓
MySQL 库存仍然是 100

MySQL 的条件更新压根没被调用过,所以谈不上”拦不拦得住”。条件更新防的是”条件不满足却仍要写入”,而这里根本没有写入动作。

结果是少卖,不是超卖:

Redis 可售库存:99
MySQL 真实库存:100

Redis 少了 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 >= ? 的全部价值:它把”库存不足”从一次数据损坏,变成一次正常的业务失败。

没有这个条件,数据库不会阻止扣减,它只会老老实实地把库存扣成负数。数据库不是业务规则的执行者,它是最后一道闸门——这道闸门要自己判断,不能指望上游永远正确。

还有两个附带影响:

  1. 库存为负数。改后可能出现 stock = -1 的数据,之后所有基于库存的判断(“还有货吗”)都要额外处理负数,而且对账公式也会失真。
  2. 失去自诊断能力。改后扣减成功,链路一路绿灯,没有任何环节会发现异常——直到用户投诉。而改前的失败是”响亮”的:扣减失败 → 走释放流程 → 订单不成立 → 用户收到”未抢到”。

什么时候可以去掉:

如果能严格保证”Redis 扣减数永远等于 MySQL 扣减数”,那这个条件确实是冗余的。但”永远保证”本身就需要一整套机制(可靠消息、幂等、对账)——而这整套机制在故障时正是最可能失效的。在一个本可以用来兜底的检查上省一次 WHERE 判断,收益极小,代价是丢掉最后一道防线。

最终答案:

去掉后超卖会重新成为可能——Redis 一旦多扣,MySQL 会把库存扣成负数并创建成功订单。同时会失去库存非负的约束和故障自诊断能力。这个条件是最后一道闸门,不应去掉。

发现内容有问题?

告诉我们哪里需要改进。