库存扣减:高并发下的库存扣减方案
想象这个场景:
秒杀开始:
- 库存: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,000 | 5,000-20,000 | 100,000+ |
| 是否超卖 | ❌ 必然超卖 | ✅ 不会 | ✅ 不会 | ✅ 不会 |
| 冲突处理 | 无 | 排队等待 | 失败重试 | 直接失败 |
| 数据落地 | 需自行处理 | 事务内完成 | 事务内完成 | 需异步同步 |
| 实现复杂度 | 极低 | 低 | 中 | 中 |
| 适用场景 | 无(只适合玩具) | 低并发强一致 | 中等并发 | 高并发秒杀 |
三条选型经验:
- 无锁方案只在教科书里成立。 它不是”性能好但有小瑕疵”,而是结果完全错误,不存在适用场景。
- 锁的本质是把并发变串行。 悲观锁和乐观锁都只是选择在哪里付出这个代价——一个付在等待上,一个付在重试上。冲突率低时乐观锁明显更优,冲突率高时两者都会崩。
- 真实系统不是四选一,而是叠加使用。 Redis 原子扣减挡住 99.9% 的无效请求,MySQL 的条件更新再挡一次,对账做最后的兜底——这正是第 6.3 节讲的三道防线。
本章是”分析”,只讲清楚每种方案为什么行、为什么不行。具体的实现从第 3 章开始。
方案选定了,接下来的问题是”怎么落地”。这里先把两个最关键的实现细节交代清楚: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
三个设计要点:
- 返回码要能区分失败原因。 只返回 0/1 的话,调用方分不清”库存不足”和”key 没初始化”,处理逻辑会写错。这里用 1 / 0 / -1 三种。
- 库存不足时不能扣减。 判断和扣减必须都在脚本里,
DECRBY一定在判断通过之后。 - 脚本要短。 脚本执行期间会阻塞这个 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}")
三个实现上的讲究:
- 用
EVALSHA而不是EVAL。 脚本体几十字节,传输一次不算什么,但每秒调用几十万次就是实打实的带宽。EVALSHA只传 SHA 值。 - 必须处理
NoScriptError。 Redis 重启、SCRIPT FLUSH、主从切换都会让 SHA 失效。捕获异常后重新加载一次即可——这是线上偶发报错的头号来源。 - 一定要用连接池。 每次调用新建 TCP 连接,在 50 万 QPS 下会直接把连接数打满,光握手就耗尽机器资源。
生产环境还要注意:Redis Cluster 下多个 key 必须落在同一个 slot,用 hash tag 把它们绑在一起;以及给 evalsha 设置合理的超时和降级策略——Redis 抖动时,秒杀服务应该快速失败,而不是把自己也拖死。
把上面的方案串起来,就是一条清晰的演进路径:
| 阶段 | 架构 | 峰值 QPS | 一致性保证 | 定位 |
|---|---|---|---|---|
| 1 | 应用直连 MySQL,无锁 | 很高(结果错) | 无 | 玩具版本 |
| 2 | MySQL + 悲观锁 | 1,000-5,000 | 行锁,强一致 | 保守但正确 |
| 3 | MySQL + 乐观锁 | 5,000-20,000 | 条件更新,强一致 | 有所改善 |
| 4 | Redis 预扣 + 消息队列 | 100,000+ | 最终一致 | 秒杀主流方案 |
| 5 | Redis + 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 的数据读写全部在内存里完成,一次 GET/DECR 是纳秒到微秒级;而 MySQL 的一次更新要经过 Buffer Pool、InnoDB 索引维护、redo log、binlog、fsync 落盘,是毫秒级。
操作 典型耗时 瓶颈 Redis GET/DECR 亚微秒 内存访问 MySQL 主键点查 毫秒级 Buffer Pool + 网络 MySQL 扣减并提交 毫秒到十毫秒级 redo / binlog 落盘 -
命令执行是单线程的:Redis 用一个线程执行所有命令,因此执行命令时根本不存在线程竞争——没有锁、没有上下文切换、没有多线程之间的缓存一致性问题。命令内部用的数据结构(哈希表、跳表、整数集合)都是非线程安全的,正因为只有一个线程在碰它们才安全。
需要澄清的是:单线程指的是”执行命令”这一步。Redis 6 之后引入了 I/O 线程,把网络读写交给多个线程处理,但命令的执行仍然回到主线程串行完成。持久化(RDB fork、AOF rewrite)在子进程里做,主从复制在另一个线程里做,都不占用命令执行的主线程。
-
IO 多路复用:单线程也能扛住几万个连接,靠的是 epoll 这类机制——一个线程同时监听成千上万个连接的可读可写事件,谁有数据就处理谁,不需要”一个连接一个线程”。这是 C10K 问题的标准解法。
-
数据结构是为 O(1) 设计的:库存是一个整数,Redis 用 intset、zset 这类结构,查找和修改都是 O(1),没有额外的指针跳转和内存间接。
-
Lua 脚本把多次操作压成一次往返:这既是第 4.1 节 Lua 脚本原子性的来源,也顺带减少了 RTT——远程调用最大的成本就是往返次数。
最终答案
Redis 快的原因是:① 数据全在内存,避开了磁盘 I/O;② 命令由单线程串行执行,没有锁竞争和线程切换开销;③ 用 IO 多路复用让单线程也能承载海量连接;④ 数据结构针对操作做了 O(1) 优化;⑤ Lua 脚本和 pipeline 把多次操作合并成一次网络往返。
需要补充的边界:单线程是优势也是限制——一条长命令或一个执行过久的 Lua 脚本会阻塞整个实例,所以脚本必须写得短。
问题 2:Redis扣减库存后,MySQL库存如何同步?
提示:
- 异步MQ消息
- 定时对账
- 最终一致性
解题思路
三条提示对应三种机制,但关键不是把它们罗列出来,而是说清楚各自的定位,以及为什么最终只能选”最终一致”。
详细步骤
-
先确定谁是事实来源:MySQL 里存着订单和成交记录,它是业务事实的最终来源;Redis 里的库存是可被重建的加速副本。同步方向由这个结论决定——实时同步走 Redis 到 MySQL,缓存重建走 MySQL 到 Redis。
-
强一致为什么不可行:Redis 和 MySQL 之间做两阶段提交,需要互相等待,锁持有时间被拉长到整个分布式事务的时长,QPS 直接掉回数据库水平,秒杀架构的意义就没了。
方案 延迟 吞吐 结论 同步双写 低 极低 不可行 分布式事务 中 极低 不可行 消息队列异步 毫秒级 高 ✅ 主链路 定时对账 分钟级 几乎不影响 ✅ 兜底 -
消息队列异步同步(主链路):Redis 扣减成功后发一条消息,消费者收到后扣 MySQL 库存 + 创建订单。Redis 扣减完就立刻返回用户成功,不等 MySQL,主链路延迟被压到最低。
-
消费端必须幂等:消费者可能因为网络抖动、重启而重复消费。用订单号做幂等键,靠唯一索引在同一个事务里保证——重复消费时 INSERT 冲突、事务回滚,库存不会被扣第二次。
-
MySQL 侧的扣减必须带
stock >= 1条件:即使 Redis 侧保证了不超卖,MySQL 侧也要自己再挡一次。Redis 多扣了,MySQL 的条件更新就能把这一单挡下来。 -
定时对账兜底:定期比对”Redis 已扣减总量”和”MySQL 已售量”,差额就是需要修复的部分。它独立于同步链路,主链路全挂了也能跑。
最终答案
用异步消息队列做主链路、定时对账做兜底,接受最终一致性。配套三件套是:消费者用订单号做幂等、MySQL 扣减带 stock >= 1 条件、对账任务独立于同步链路运行。详见第 6.1、6.2、6.3 节。
问题 3:Redis故障怎么办?
提示:
- Redis持久化(AOF/RDB)
- Redis集群高可用
- 故障降级方案
解题思路
这个问题要分两层回答:数据怎么不丢(持久化与高可用),以及Redis 挂了这几秒用户看到什么(降级)。只答第一层是不够的,因为秒杀的高峰期恰好是最需要它活着的时候。
详细步骤
-
持久化保证数据不丢:
- AOF 记录每一条写命令,Redis 6 之后支持 everysec(最多丢约 1 秒)和 always(每条都刷盘,最安全但最慢)。库存场景优先用 AOF everysec。
- RDB 是内存快照,间隔久、恢复快,但可能丢一个周期的数据。两者通常一起开:AOF 保证精度,RDB 保证大规模恢复速度。
-
集群高可用保证实例挂了还能用:
- 主从 + Sentinel 做自动故障转移,客户端通过 Sentinel 拿到新的主节点地址。
- Redis Cluster 做分片,突破单机内存和吞吐上限。
- 注意主从复制是异步的:故障切换时可能丢掉最后一批还没同步到从节点的写。库存场景要接受这个窗口,并用对账来修。
-
降级方案决定用户体验:
级别 手段 结果 一级 本地缓存(Caffeine)兜底 用略微陈旧的库存做判断,误判概率低 二级 直接查 MySQL + 条件更新 慢但正确,QPS 掉到几千 三级 收紧限流 保护数据库不被打死 四级 返回”系统繁忙,请稍后再试” 用户明确知道没抢到,而不是页面卡住 -
降级时的底线:绝对不能因为 Redis 挂了就放行超卖。MySQL 侧的
stock >= 1条件更新必须保留——它正是 Redis 防线失效时的兜底。降级可以慢,不能错。 -
恢复之后:Redis 从 MySQL 重建库存(binlog 订阅或活动前重新初始化),再跑一次对账,把故障窗口内的差异修回来。
-
监控不能少:AOF 重写耗时、主从延迟、内存使用率、脚本执行时长、连接数——这几项任意一项异常都要在活动开始前发现。
最终答案
持久化(AOF + RDB)保证数据不丢,Sentinel / Cluster 保证实例挂了还能用,降级阶梯保证用户体验可控,而 MySQL 的条件更新保证即使 Redis 完全失效也不会超卖。恢复后重建 Redis 并对账修复差异。
发现内容有问题?
告诉我们哪里需要改进。
