库存扣减:高并发下的库存扣减方案

场景:50万人抢购100台iPhone 📱

想象这个场景:

秒杀开始:

  • 库存:100台iPhone 15 Pro
  • 参与用户:50万人
  • 同时点击:10万人

问题:

  • 如何确保100台iPhone正好卖给100个用户?
  • 如何避免超卖(卖出101台)?
  • 如何避免少卖(只卖出99台)?

这是一个经典的并发扣减库存问题!

问题演示:并发扣减库存的坑

四种方案依次登场。先看最直觉的那种:读库存、判断库存、扣减库存,三步走。

它的问题不在于哪一步写错了,而在于三步之间存在时间缝隙。而这个缝隙在 50 万 QPS 下会被放大成一场灾难——本来只会多卖 1 件的竞态,会变成多卖几百件。

方案一:无锁方案(最简单但会超卖)

典型输出:

🧪 测试无锁方案:

  用户1: 读到库存=100
  用户2: 读到库存=100
  用户3: 读到库存=100
  ...
  用户1: 购买成功!库存=99
  用户2: 购买成功!库存=99  ← 两人同时买到!
  用户3: 购买成功!库存=98

📊 结果:
   初始库存: 100
   剩余库存: 90
   已售数量: 10
   总交易: 20
   
   ❌ 超卖!实际售出10件,但库存只减少了10件
   ❌ 数据不一致!

问题分析:

时间轴:
T1: 用户A读库存=100
T2: 用户B读库存=100  ← A和B读到相同的值!
T3: 用户A判断100>0,准备扣减
T4: 用户B判断100>0,准备扣减
T5: 用户A扣减库存=99
T6: 用户B扣减库存=99  ← 应该是98!
T7: 用户A创建订单
T8: 用户B创建订单  ← 两个订单,但只扣了一次库存

❌ 超卖!

方案二:数据库悲观锁(可靠但性能差)

最直接的修法是:在读库存的时候就把这一行锁住,让别人排队等。

BEGIN;

-- 关键:FOR UPDATE 在这一行上加排他锁,拿不到锁就一直等
SELECT stock FROM product WHERE id = 1 FOR UPDATE;

-- 应用层判断:if stock > 0:
UPDATE product SET stock = stock - 1 WHERE id = 1;

COMMIT;

时间轴变成了这样:

T1: 事务A SELECT ... FOR UPDATE → 拿到行锁,读到 stock=100
T2: 事务B SELECT ... FOR UPDATE → 阻塞等待 🔒
T3: 事务C SELECT ... FOR UPDATE → 阻塞等待 🔒
T4: 事务A 判断 100 > 0,UPDATE stock=99,COMMIT,释放锁
T5: 事务B 拿到锁,读到 stock=99 → 判断 → 扣减 → stock=98
T6: 事务C 拿到锁,读到 stock=98 → 判断 → 扣减 → stock=97

超卖没有了,但吞吐被锁住了:50 万个请求变成 50 万次串行的事务。锁的等待时间还会一路传导——第 5000 个请求要等前面 4999 个全部完成。

而且锁的持有时间不只是业务逻辑的时间,还包括网络往返、事务提交、日志落盘。数据库的连接池会被大量等待中的事务占满,正常的业务查询也开始排队。

实测下来,单库悲观锁的峰值在 1,000-5,000 QPS,距离秒杀需要的 50 万 QPS 差了两个数量级。具体原理和调优细节见第 3.1 节。

方案三:数据库乐观锁(有一定改进)

既然排队等锁太慢,那就换个思路:不锁,先干,冲突了再回头重做。

乐观锁靠一个单调递增的版本号来发现”我读到的数据被人改过”:

-- 第一步:读数据和版本号(不加锁)
SELECT stock, version FROM product WHERE id = 1;
-- 假设读到 stock=100, version=7

-- 第二步:把判断和更新合成一条语句
UPDATE product
SET stock = stock - 1, version = version + 1
WHERE id = 1 AND version = 7 AND stock >= 1;

如果这条 UPDATE 影响行数是 1,说明扣减成功;如果影响行数是 0,说明 version = 7 这个条件已经不成立了——在我们读出来到执行 UPDATE 之间,已经有人改过这一行,本次失败。

并发 10 个请求抢最后 1 件:
  请求A: SELECT → stock=1, version=7
  请求B: SELECT → stock=1, version=7    ← 和 A 读到的是同一份
  请求A: UPDATE ... WHERE version=7 AND stock>=1 → 影响 1 行 ✅
         (此刻 stock=0, version=8)
  请求B: UPDATE ... WHERE version=7 AND stock>=1 → 影响 0 行 ❌(version 已经不是 7 了)

和悲观锁对比,改进在哪:

维度悲观锁乐观锁
冲突时的表现阻塞等待立即失败
并发度同一条记录上串行所有请求并行读
等待发生在哪持锁期间重试期间,且只针对少数失败请求
额外成本加锁 + 解锁 + 长事务一个 version 字段

代价是重试:冲突率越高,重试越多,重试又会推高冲突率。50 万人抢 100 件时,冲突率高达 5000 倍,乐观锁也会被打崩。

实现细节、重试策略和 ABA 问题见第 3.2 节。

方案四:Redis原子操作(推荐方案)⚡

两个数据库方案共同的瓶颈是磁盘 I/O。把库存放到内存里,绕开磁盘,这个瓶颈就不存在了。

Redis 扣库存的核心是”判断”和”扣减”必须是一个不可分割的动作。单条 Redis 命令是原子的,但多条命令组合起来不是——

-- ❌ 有竞态:GET 和 DECR 之间有缝隙
local stock = redis.call('GET', KEYS[1])
if tonumber(stock) > 0 then
  redis.call('DECR', KEYS[1])
end

-- ✅ 原子:整段脚本在 Redis 中一次性执行完
if redis.call('GET', KEYS[1]) > 0 then
  return redis.call('DECR', KEYS[1])
end
return -1

Redis 执行脚本期间不会处理其他命令,所以这段判断和扣减天然互斥,不需要任何锁。

优势是全方位的:

  • 纯内存操作,单次扣减在微秒级
  • 单线程执行模型,没有锁竞争、没有线程切换
  • 一条命令就能完成”判断 + 扣减 + 返回结果”,网络往返只有一次
  • 峰值吞吐轻松达到 10 万 QPS 以上

代价也很明确:Redis 里的数据不是最终事实。扣减成功后还要可靠地同步回 MySQL,这是第 6 章的主题。

Lua 脚本的写法和调用细节见第 4.1 节。

方案对比总结

把四个方案放在一起,选型的依据就清楚了:

维度无锁方案数据库悲观锁数据库乐观锁Redis 原子操作
原子性保证❌ 无✅ 行锁✅ 条件更新✅ 单线程执行
峰值 QPS极高(但结果错)1,000-5,0005,000-20,000100,000+
是否超卖❌ 必然超卖✅ 不会✅ 不会✅ 不会
冲突处理无排队等待失败重试直接失败
数据落地需自行处理事务内完成事务内完成需异步同步
实现复杂度极低低中中
适用场景无(只适合玩具)低并发强一致中等并发高并发秒杀

三条选型经验:

  1. 无锁方案只在教科书里成立。 它不是”性能好但有小瑕疵”,而是结果完全错误,不存在适用场景。
  2. 锁的本质是把并发变串行。 悲观锁和乐观锁都只是选择在哪里付出这个代价——一个付在等待上,一个付在重试上。冲突率低时乐观锁明显更优,冲突率高时两者都会崩。
  3. 真实系统不是四选一,而是叠加使用。 Redis 原子扣减挡住 99.9% 的无效请求,MySQL 的条件更新再挡一次,对账做最后的兜底——这正是第 6.3 节讲的三道防线。

本章是”分析”,只讲清楚每种方案为什么行、为什么不行。具体的实现从第 3 章开始。

Redis原子操作的实现细节

方案选定了,接下来的问题是”怎么落地”。这里先把两个最关键的实现细节交代清楚:Lua 脚本凭什么能做到原子,以及调用方怎么把它跑起来。第 4.1 节会给出完整的生产级实现。

Lua脚本详解

为什么必须是 Lua

Redis 的单条命令是原子的,但多条命令的组合不是:

❌ 分两步:
  stock = GET stock_key
  if stock > 0 then
      DECR stock_key
  end
  → GET 和 DECR 之间有间隙,别的请求能插进来
  → 100 个请求可能同时通过判断,扣出 101 件

✅ 一步:
  EVALSHA script_sha 1 stock_key 1
  → 整个脚本作为一个原子单元执行,执行期间 Redis 不处理其他命令

Redis 执行脚本是单线程串行的:脚本跑到结束之前,其他命令只能排队。这不是”加了一把锁”,而是根本没有并发可言。

脚本实现

-- deduct_stock.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

三个设计要点:

  1. 返回码要能区分失败原因。 只返回 0/1 的话,调用方分不清”库存不足”和”key 没初始化”,处理逻辑会写错。这里用 1 / 0 / -1 三种。
  2. 库存不足时不能扣减。 判断和扣减必须都在脚本里,DECRBY 一定在判断通过之后。
  3. 脚本要短。 脚本执行期间会阻塞这个 Redis 实例上的所有其他请求。脚本里绝不能做循环、RPC、或者任何耗时操作。

顺带一提:如果只想扣减不判断,用 DECRBY 一条命令就够了,不需要脚本。脚本的价值在于把”判断”和”扣减”合成一个原子单元。

Python实现

import redis

DEDUCT_SCRIPT = """
local stock = redis.call('GET', KEYS[1])
if not stock then
  return -1
end
if tonumber(stock) < tonumber(ARGV[1]) then
  return 0
end
redis.call('DECRBY', KEYS[1], ARGV[1])
return 1
"""

pool = redis.ConnectionPool(   # 连接池:秒杀是短连接高并发场景,必须复用连接
    host='127.0.0.1',
    port=6379,
    db=0,
    max_connections=200,
    socket_timeout=1,
    decode_responses=True,
)
r = redis.Redis(connection_pool=pool)

_deduct_sha = None


def _load_script() -> str:
    """加载脚本并缓存 SHA,避免每次调用都传脚本体"""
    global _deduct_sha
    if _deduct_sha is None:
        _deduct_sha = r.script_load(DEDUCT_SCRIPT)
    return _deduct_sha


def try_deduct(stock_key: str, quantity: int = 1) -> bool:
    """扣减库存。返回 True 表示扣减成功。"""
    sha = _load_script()
    try:
        result = r.evalsha(sha, 1, stock_key, quantity)
    except redis.exceptions.NoScriptError:
        # Redis 重启或 SCRIPT FLUSH 后 SHA 失效,重新加载一次
        sha = _load_script()
        result = r.evalsha(sha, 1, stock_key, quantity)

    if result == 1:
        return True
    if result == 0:
        return False
    raise RuntimeError(f"库存 key 不存在: {stock_key}")

三个实现上的讲究:

  1. 用 EVALSHA 而不是 EVAL。 脚本体几十字节,传输一次不算什么,但每秒调用几十万次就是实打实的带宽。EVALSHA 只传 SHA 值。
  2. 必须处理 NoScriptError。 Redis 重启、SCRIPT FLUSH、主从切换都会让 SHA 失效。捕获异常后重新加载一次即可——这是线上偶发报错的头号来源。
  3. 一定要用连接池。 每次调用新建 TCP 连接,在 50 万 QPS 下会直接把连接数打满,光握手就耗尽机器资源。

生产环境还要注意:Redis Cluster 下多个 key 必须落在同一个 slot,用 hash tag 把它们绑在一起;以及给 evalsha 设置合理的超时和降级策略——Redis 抖动时,秒杀服务应该快速失败,而不是把自己也拖死。

Redis vs 数据库:架构演进

把上面的方案串起来,就是一条清晰的演进路径:

阶段架构峰值 QPS一致性保证定位
1应用直连 MySQL,无锁很高(结果错)无玩具版本
2MySQL + 悲观锁1,000-5,000行锁,强一致保守但正确
3MySQL + 乐观锁5,000-20,000条件更新,强一致有所改善
4Redis 预扣 + 消息队列100,000+最终一致秒杀主流方案
5Redis + MQ + MySQL 条件更新 + 对账100,000+最终一致 + 兜底防线生产级方案

每一阶段都是把瓶颈往后推一格。

阶段 1 到 2:瓶颈是”数据算错了”,用锁解决。 阶段 2 到 3:瓶颈是”排队太慢”,用版本号换掉阻塞。 阶段 3 到 4:瓶颈是”磁盘 I/O 撑不住”,用内存换掉磁盘。 阶段 4 到 5:瓶颈是”两个系统的数据对不上”,用消息队列 + 对账解决。

要特别强调的是:Redis 不是 MySQL 的替代品。

在这个架构里,Redis 承担的是”决定谁有资格买”这件事——它快,所以能在 50 万 QPS 下完成筛选,挡掉 99.9% 注定失败的请求。MySQL 承担的是”记录这笔交易”——它是最终事实,订单和成交记录都在这里,需要事务、需要持久化、需要能被财务审计。

用户请求
   ↓
Redis Lua 原子扣减 ── 抢到了?──否──→ 直接返回"已售罄"(到此为止,不打扰 MySQL)
   ↓ 是
入队(Kafka / RocketMQ)
   ↓
消费者:扣 MySQL 库存(条件更新)+ 创建订单
   ↓
对账任务:定期比对 Redis 与 MySQL,修复差异

这个架构里有一个重要的角色转换:第 3 章我们费尽心思优化数据库,出发点是”让数据库扛住秒杀流量”;到了第 4 章,出发点变成了”让数据库根本看不到那 99.9% 的流量”。数据库的 QPS 从 50 万降到几千,悲观锁和乐观锁的取舍才重新变得有意义——它们不再是”够不够快”的问题,而是”最后一道防线要正不正确”的问题。

后面的章节会把这套架构的每个零件展开:第 4 章讲 Redis 预扣和消息队列,第 5 章讲限流与公平性,第 6 章讲一致性和防超卖,第 7 章讲反作弊。

想一想

这一页把四种方案摆在一起做了对比。带着下面三个问题往下读,会更容易理解后面每一章为什么要那么设计。

问题 1:为什么Redis性能这么高?

提示:

  • 内存操作 vs 磁盘操作
  • 单线程无锁竞争
  • 原子操作无需加锁
Redis性能原理秒杀架构

解题思路

这个问题要拆成三个独立的子问题回答:数据放在哪里、命令谁来执行、网络连接怎么处理。Redis 的快不是靠单一优化,而是这几者叠加的结果。

详细步骤

  1. 纯内存操作:Redis 的数据读写全部在内存里完成,一次 GET/DECR 是纳秒到微秒级;而 MySQL 的一次更新要经过 Buffer Pool、InnoDB 索引维护、redo log、binlog、fsync 落盘,是毫秒级。

    操作典型耗时瓶颈
    Redis GET/DECR亚微秒内存访问
    MySQL 主键点查毫秒级Buffer Pool + 网络
    MySQL 扣减并提交毫秒到十毫秒级redo / binlog 落盘
  2. 命令执行是单线程的:Redis 用一个线程执行所有命令,因此执行命令时根本不存在线程竞争——没有锁、没有上下文切换、没有多线程之间的缓存一致性问题。命令内部用的数据结构(哈希表、跳表、整数集合)都是非线程安全的,正因为只有一个线程在碰它们才安全。

    需要澄清的是:单线程指的是”执行命令”这一步。Redis 6 之后引入了 I/O 线程,把网络读写交给多个线程处理,但命令的执行仍然回到主线程串行完成。持久化(RDB fork、AOF rewrite)在子进程里做,主从复制在另一个线程里做,都不占用命令执行的主线程。

  3. IO 多路复用:单线程也能扛住几万个连接,靠的是 epoll 这类机制——一个线程同时监听成千上万个连接的可读可写事件,谁有数据就处理谁,不需要”一个连接一个线程”。这是 C10K 问题的标准解法。

  4. 数据结构是为 O(1) 设计的:库存是一个整数,Redis 用 intset、zset 这类结构,查找和修改都是 O(1),没有额外的指针跳转和内存间接。

  5. Lua 脚本把多次操作压成一次往返:这既是第 4.1 节 Lua 脚本原子性的来源,也顺带减少了 RTT——远程调用最大的成本就是往返次数。

最终答案

Redis 快的原因是:① 数据全在内存,避开了磁盘 I/O;② 命令由单线程串行执行,没有锁竞争和线程切换开销;③ 用 IO 多路复用让单线程也能承载海量连接;④ 数据结构针对操作做了 O(1) 优化;⑤ Lua 脚本和 pipeline 把多次操作合并成一次网络往返。

需要补充的边界:单线程是优势也是限制——一条长命令或一个执行过久的 Lua 脚本会阻塞整个实例,所以脚本必须写得短。

问题 2:Redis扣减库存后,MySQL库存如何同步?

提示:

  • 异步MQ消息
  • 定时对账
  • 最终一致性
最终一致性消息队列库存同步

解题思路

三条提示对应三种机制,但关键不是把它们罗列出来,而是说清楚各自的定位,以及为什么最终只能选”最终一致”。

详细步骤

  1. 先确定谁是事实来源:MySQL 里存着订单和成交记录,它是业务事实的最终来源;Redis 里的库存是可被重建的加速副本。同步方向由这个结论决定——实时同步走 Redis 到 MySQL,缓存重建走 MySQL 到 Redis。

  2. 强一致为什么不可行:Redis 和 MySQL 之间做两阶段提交,需要互相等待,锁持有时间被拉长到整个分布式事务的时长,QPS 直接掉回数据库水平,秒杀架构的意义就没了。

    方案延迟吞吐结论
    同步双写低极低不可行
    分布式事务中极低不可行
    消息队列异步毫秒级高✅ 主链路
    定时对账分钟级几乎不影响✅ 兜底
  3. 消息队列异步同步(主链路):Redis 扣减成功后发一条消息,消费者收到后扣 MySQL 库存 + 创建订单。Redis 扣减完就立刻返回用户成功,不等 MySQL,主链路延迟被压到最低。

  4. 消费端必须幂等:消费者可能因为网络抖动、重启而重复消费。用订单号做幂等键,靠唯一索引在同一个事务里保证——重复消费时 INSERT 冲突、事务回滚,库存不会被扣第二次。

  5. MySQL 侧的扣减必须带 stock >= 1 条件:即使 Redis 侧保证了不超卖,MySQL 侧也要自己再挡一次。Redis 多扣了,MySQL 的条件更新就能把这一单挡下来。

  6. 定时对账兜底:定期比对”Redis 已扣减总量”和”MySQL 已售量”,差额就是需要修复的部分。它独立于同步链路,主链路全挂了也能跑。

最终答案

用异步消息队列做主链路、定时对账做兜底,接受最终一致性。配套三件套是:消费者用订单号做幂等、MySQL 扣减带 stock >= 1 条件、对账任务独立于同步链路运行。详见第 6.1、6.2、6.3 节。

问题 3:Redis故障怎么办?

提示:

  • Redis持久化(AOF/RDB)
  • Redis集群高可用
  • 故障降级方案
Redis 高可用故障降级秒杀架构

解题思路

这个问题要分两层回答:数据怎么不丢(持久化与高可用),以及Redis 挂了这几秒用户看到什么(降级)。只答第一层是不够的,因为秒杀的高峰期恰好是最需要它活着的时候。

详细步骤

  1. 持久化保证数据不丢:

    • AOF 记录每一条写命令,Redis 6 之后支持 everysec(最多丢约 1 秒)和 always(每条都刷盘,最安全但最慢)。库存场景优先用 AOF everysec。
    • RDB 是内存快照,间隔久、恢复快,但可能丢一个周期的数据。两者通常一起开:AOF 保证精度,RDB 保证大规模恢复速度。
  2. 集群高可用保证实例挂了还能用:

    • 主从 + Sentinel 做自动故障转移,客户端通过 Sentinel 拿到新的主节点地址。
    • Redis Cluster 做分片,突破单机内存和吞吐上限。
    • 注意主从复制是异步的:故障切换时可能丢掉最后一批还没同步到从节点的写。库存场景要接受这个窗口,并用对账来修。
  3. 降级方案决定用户体验:

    级别手段结果
    一级本地缓存(Caffeine)兜底用略微陈旧的库存做判断,误判概率低
    二级直接查 MySQL + 条件更新慢但正确,QPS 掉到几千
    三级收紧限流保护数据库不被打死
    四级返回”系统繁忙,请稍后再试”用户明确知道没抢到,而不是页面卡住
  4. 降级时的底线:绝对不能因为 Redis 挂了就放行超卖。MySQL 侧的 stock >= 1 条件更新必须保留——它正是 Redis 防线失效时的兜底。降级可以慢,不能错。

  5. 恢复之后:Redis 从 MySQL 重建库存(binlog 订阅或活动前重新初始化),再跑一次对账,把故障窗口内的差异修回来。

  6. 监控不能少:AOF 重写耗时、主从延迟、内存使用率、脚本执行时长、连接数——这几项任意一项异常都要在活动开始前发现。

最终答案

持久化(AOF + RDB)保证数据不丢,Sentinel / Cluster 保证实例挂了还能用,降级阶梯保证用户体验可控,而 MySQL 的条件更新保证即使 Redis 完全失效也不会超卖。恢复后重建 Redis 并对账修复差异。

发现内容有问题?

告诉我们哪里需要改进。