Redis预扣:使用Redis原子操作预扣库存
上一章我们发现:
数据库锁方案性能:
- 悲观锁:1,000-5,000 QPS
- 乐观锁:5,000-20,000 QPS
秒杀需求:
- QPS:500,000+
- 差距:25-500倍!
核心问题:数据库是磁盘存储,I/O速度慢,无法支撑高并发。
解决思路:用内存数据库Redis替代MySQL!
Redis 快的原因不是一个,而是几个因素叠加的结果。逐个拆开看。
1. 纯内存操作
Redis 的数据读写全部在内存里完成,一次 GET/DECR 是亚微秒级。MySQL 的一次更新要走 Buffer Pool、InnoDB 索引维护、redo log、binlog、fsync 落盘,是毫秒到十毫秒级。
| 操作 | 典型耗时 | 主要瓶颈 |
|---|---|---|
| Redis GET / DECR | 亚微秒 | 内存访问 |
| MySQL 主键点查(走 Buffer Pool) | 毫秒级 | 网络往返 + SQL 解析 |
| MySQL 扣减并提交事务 | 毫秒到十毫秒级 | redo / binlog 落盘 |
| MySQL 冷数据读 | 十毫秒以上 | 磁盘随机读 |
2. 命令执行是单线程的
这是最容易被误解、也最重要的一点。
Redis 用一个线程执行所有命令。因此在执行命令时,根本不存在线程竞争——没有锁、没有线程切换、没有多线程之间的缓存一致性问题。
Redis 用的是 hash table、skip list、intset 这些非线程安全的数据结构,正因为只有一个线程在操作它们才安全。如果 Redis 是多线程的,这些结构全都要加锁,性能反而会塌下来。
需要澄清的是”单线程”到底指什么:
- 单线程的是”执行命令”这一步。 Redis 6 之后引入了 I/O 线程,把网络读写交给多个线程并行处理,但命令本身的执行仍然回到主线程串行完成。
- 持久化(RDB 的 fork、AOF rewrite)在子进程里做,主从复制在另一个线程里做,都不占用命令执行的主线程。
3. IO 多路复用
单线程也能扛住几万个连接,靠的是 epoll 这类机制:一个线程同时监听成千上万个连接的可读可写事件,谁有数据就处理谁,不需要一个连接一个线程。这是 C10K 问题的标准解法。
4. 数据结构为 O(1) 而设计
库存是一个整数,Redis 用 intset、ziplist 这类结构,查找和修改都是 O(1),没有额外的指针跳转和内存间接。
5. 一次往返完成多个操作
Lua 脚本让”判断 + 扣减”在服务端一次执行完;pipeline 则把多次命令打包成一次网络发送。RTT 是远程调用最大的成本,把它压到 1 次是最大的收益。
边界也要说清楚:
| 风险 | 说明 | 应对 |
|---|---|---|
| 大 key | 几万元素的集合,一次操作耗时几毫秒到几十毫秒 | 拆分 key,避免大集合 |
| 长脚本 | 脚本执行期间阻塞整个实例 | 脚本必须短,循环类逻辑放到应用层 |
| 慢命令 | KEYS * 之类的命令会拖垮实例 | 用 SCAN 替代,生产禁用危险命令 |
| 内存淘汰 | 内存打满后触发淘汰策略,可能把库存 key 淘汰掉 | 库存 key 使用 noeviction 并单独监控 |
最后一条在秒杀里是致命的:库存 key 被 LRU 淘汰,等于凭空多出 100 件货。 库存这类”不能丢的数据”必须用不同的淘汰策略,或者干脆用 noeviction 策略并在内存打满时快速失败。
把库存放进 Redis 只是搬了个家,真正要解决的是”怎么扣”——“判断有没有货”和”扣减库存”必须是一个不可分割的动作。
方案1:使用DECR命令
最简单的思路是直接用 DECR:把库存减 1,返回值就是剩余库存。
DECR stock:1 # 返回 9
DECR stock:1 # 返回 8
...
DECR 本身是原子的,所以”两个请求同时 DECR”不会丢失更新——库存只会准确地少 1,绝不会少 2。
但 DECR 只负责减,不负责判断。 库存减到负数,是它不管的事。所以如果直接用它,库存会变成 -1、-2、-3……
补救的做法是”先减,再看结果,负了就补回去”:
remaining = DECR stock:1
if remaining < 0:
INCR stock:1 # 补回来
return 失败
这个写法看起来能解决问题,但它不是原子的:
请求A: DECR → -1 (库存本来是 0)
请求B: DECR → -2 ← 在 A 补回之前,B 也扣了
请求A: INCR → -1
请求B: INCR → 0 ← 库存被补了 2 次,比原本还多!
结果是超卖——库存被”补”回了比应有更多的量。而且这个竞态在 50 万 QPS 下几乎必然发生。
这个失败案例正好说明了为什么需要 Lua:判断和扣减必须合并成一个原子单元,而不是靠客户端”先做再补救”。
输出结果:
✅ 初始化商品1库存:10
测试扣减:
第 1次扣减:✅ 成功,剩余库存:9
第 2次扣减:✅ 成功,剩余库存:8
第 3次扣减:✅ 成功,剩余库存:7
...
第10次扣减:✅ 成功,剩余库存:0
第11次扣减:❌ 失败,剩余库存:0
第12次扣减:❌ 失败,剩余库存:0
...
注意输出里的一个细节:第 11 次扣减失败时,“剩余库存”仍然是 0,而不是 -1。库存不会因为失败而变成负数——这正是我们要的:库存值要始终如实反映可售数量,而不是一个算术中间态。
第 4 节的完整实现里,“扣减”和”判断”是由 Redis 侧的脚本一次性完成的,所以失败时库存纹丝不动。
方案2:使用Lua脚本(推荐)⭐
Lua 脚本把”读、判断、写”三步在 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
redis.call('DECRBY', KEYS[1], ARGV[1])
return 1
三个设计要点:
- 判断在扣减之前。 库存不够时直接返回 0,不执行 DECRBY。库存值永远不会被扣成负数,也不需要任何”补回来”的补救逻辑。
- 返回码要能区分失败原因。 1 / 0 / -1 分别代表成功、库存不足、key 未初始化。调用方拿到 0 就返回”已售罄”,拿到 -1 应该报警——这是配置错误,不是正常业务结果。
- 脚本要短。 脚本执行期间会阻塞这个实例上的所有其他请求。绝不能在里面写循环、不能做 RPC、不能调外部服务。
调用方式
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
"""
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
deduct_sha = r.script_load(DEDUCT_SCRIPT)
def try_deduct(stock_key: str, quantity: int = 1) -> bool:
try:
result = r.evalsha(deduct_sha, 1, stock_key, quantity)
except redis.exceptions.NoScriptError:
# Redis 重启或 SCRIPT FLUSH 后 SHA 失效,重新加载
global deduct_sha
deduct_sha = r.script_load(DEDUCT_SCRIPT)
result = r.evalsha(deduct_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 失效。这是线上偶发报错的头号来源,捕获后重新加载一次即可。
Redis Cluster 下的注意:脚本涉及多个 key 时,这些 key 必须落在同一个 slot。用 hash tag 把它们绑在一起:
stock:{sku_1001}:available
order:{sku_1001}:user_888
↑ 同一个 slot
Lua 脚本 vs Redis Function:Redis 7 引入了 Function,写法和 Lua 几乎一样,但能被脚本缓存机制更好地管理,也限制了对危险命令的访问。新项目优先用 Function,老项目用 Lua 也完全没问题——核心的原子性保证是同一个。
测试结果:
============================================================
并发测试:10000个用户抢购100件商品
============================================================
📊 测试结果:
总请求数:10000
成功数:100
失败数:9900
总耗时:1523.45ms
平均响应时间:0.15ms
QPS:6564
最终库存:0
扣减数量:100
原子性验证:✅ 通过
注意结果里的两个关键数字:成功数正好是 100,和初始库存一致;最终库存是 0,不是 -9900。这说明扣减和判断确实是一个不可分割的原子动作——如果判断和扣减是两步,中间就会漏出负数。
| 维度 | DECR + 手动回补 | DECR 裸用 | Lua 脚本 |
|---|---|---|---|
| 原子性 | ❌ DECR 和 INCR 之间有间隙 | ✅ 单命令原子 | ✅ 整个脚本原子 |
| 库存会不会变负 | ❌ 会,需要回补 | ❌ 会 | ✅ 不会 |
| 超卖风险 | ❌ 有(回补次数错乱就会超卖) | ❌ 有 | ✅ 无 |
| 网络往返 | 2 次(DECR + INCR) | 1 次 | 1 次 |
| 失败信息 | 粗(只知道减了) | 粗(负数含义不明确) | 细(能区分不足/未初始化) |
| 逻辑位置 | 分散在客户端各处 | 客户端 | 收敛在服务端一处 |
| 维护成本 | 高(每个调用方都要写对) | 低但不安全 | 低(逻辑只有一份) |
| 适用 | 不推荐用于库存 | 纯计数、允许出错的场景 | 库存扣减等强一致要求场景 |
三个最关键的差别:
- 原子性。
DECR单独用是原子的,但”减 + 判断 + 回补”这个组合不是。Lua 脚本把组合变成了一个原子单元。 - 库存语义。 库存是不能为负的业务字段,不是普通计数器。
DECR裸用会让它变成 -1、-2,破坏”库存值 = 可售数量”这个不变量。Lua 脚本在扣减前判断,保证库存永远是一个诚实的数字。 - 逻辑收敛。 用 Lua 之后,“怎么扣”这个规则只存在于一份脚本里,客户端不需要各自实现一遍。规则的唯一性比规则的执行速度更重要——一旦有第二个调用方写错了回补逻辑,超卖就来了。
什么时候 DECR 就够了:如果你的场景允许最终少算、允许负数(比如统计 PV、限流计数器),那 DECR 足够,而且更快。但库存不是这种场景。
把三种方案放在同一台机器上压测,差距非常明显:
| 方案 | 峰值 QPS | 平均响应 | 说明 |
|---|---|---|---|
| MySQL 悲观锁 | 1,000-5,000 | 10-500ms | 同一行上串行,连接池被等待请求占满 |
| MySQL 乐观锁 | 5,000-20,000 | 1-5ms | 冲突时重试,冲突率高时雪崩 |
| Redis Lua 原子扣减 | 100,000+ | 小于 1ms | 内存操作 + 单线程原子执行 |
| 差距 | 25-500 倍 |
回到前面那个 10000 用户的并发测试:
总请求数:10000
成功数:100
失败数:9900
总耗时:1523.45ms
平均响应时间:0.15ms
QPS:6564
这里的 6564 QPS 是单进程 Python 客户端的瓶颈,不是 Redis 的上限。
单进程 Python 用 requests 逐个发请求,光是建立 TCP 连接、Python 解释器开销、GC 就吃掉了绝大部分时间。换成多进程 + 连接池 + pipeline,同样的 Redis 实例能跑出 10 万以上的 QPS。
所以看压测数据要分清三段瓶颈:
客户端(Python 脚本、网络往返) → 代理层(Nginx、网关) → Redis
6564 QPS 通常不是瓶颈 100,000+ QPS
压测时必须确认瓶颈在哪一段,否则很容易得出”Redis 只有 6000 QPS”这种错误结论。压测工具要压满服务端,客户端要足够并行。
还有一个容易被忽略的点:Redis 的 QPS 上限和命令复杂度强相关。GET/DECR 这种 O(1) 命令能跑 10 万以上,但如果脚本里有循环、或者用了 KEYS *,性能会断崖式下跌。保持脚本简单,是保住高 QPS 的前提。
把前面的东西组装成一个能跑的最小系统。
import time
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])
redis.call('INCRBY', KEYS[2], ARGV[1])
return 1
"""
RELEASE_SCRIPT = """
local stock = redis.call('GET', KEYS[1])
if not stock then
return -1
end
redis.call('INCRBY', KEYS[1], ARGV[1])
redis.call('DECRBY', KEYS[2], ARGV[1])
return 1
"""
class StockService: # 库存服务
def __init__(self, host='127.0.0.1', port=6379, db=0):
pool = redis.ConnectionPool(
host=host,
port=port,
db=db,
max_connections=200,
socket_timeout=1,
decode_responses=True,
)
self.redis = redis.Redis(connection_pool=pool)
self._deduct_sha = self.redis.script_load(DEDUCT_SCRIPT)
self._release_sha = self.redis.script_load(RELEASE_SCRIPT)
def init_stock(self, product_id: int, stock: int):
"""活动开始前初始化库存"""
self.redis.set(f'stock:{product_id}', stock)
# 累计扣减量,用于对账
self.redis.set(f'stock:deducted:{product_id}', 0)
def try_deduct(self, product_id: int, quantity: int = 1) -> bool:
"""扣减库存。True = 扣减成功,False = 库存不足"""
key = f'stock:{product_id}'
counter = f'stock:deducted:{product_id}'
try:
result = self.redis.evalsha(
self._deduct_sha, 2, key, counter, quantity
)
except redis.exceptions.NoScriptError:
self._deduct_sha = self.redis.script_load(DEDUCT_SCRIPT)
result = self.redis.evalsha(
self._deduct_sha, 2, key, counter, quantity
)
if result == 1:
return True
if result == 0:
return False
raise RuntimeError(f'库存 key 未初始化: {key}')
def release(self, product_id: int, quantity: int = 1):
"""回补库存(超时未支付释放、退款)"""
key = f'stock:{product_id}'
counter = f'stock:deducted:{product_id}'
try:
result = self.redis.evalsha(
self._release_sha, 2, key, counter, quantity
)
except redis.exceptions.NoScriptError:
self._release_sha = self.redis.script_load(RELEASE_SCRIPT)
result = self.redis.evalsha(
self._release_sha, 2, key, counter, quantity
)
if result == -1:
raise RuntimeError(f'库存 key 未初始化: {key}')
if __name__ == '__main__': # 演示
service = StockService()
service.init_stock(product_id=1, stock=100)
start = time.time()
success = 0
fail = 0
for user_id in range(1, 10001):
if service.try_deduct(product_id=1):
success += 1
else:
fail += 1
elapsed = (time.time() - start) * 1000
print(f'成功 {success} / 失败 {fail}')
print(f'总耗时 {elapsed:.2f}ms')
print(f'剩余库存 {service.redis.get("stock:1")}')
几个必须注意的实现细节:
- 回补库存也要用脚本。
release里的 INCRBY 同样放在 Lua 里执行,保证”回补”和”读取剩余量”是一个原子动作。回补是超卖的高发点——重复回补一次,就凭空多出一件可售商品。 stock:deducted:{id}这个计数器是给对账用的。 它记录”Redis 一共扣了多少”,对账时拿它和 MySQL 的已售量比对,差额就是需要修复的部分。把它放进同一个 Lua 脚本一起更新,否则扣减成功但计数失败,账就永远对不上。- 释放库存必须幂等。 超时释放的定时任务可能重复执行,必须用订单号做幂等键,否则会重复回补导致超卖。
- key 要带上业务维度。
stock:{product_id}而不是stock,多商品活动才不会互相干扰。
生产环境还要补的东西(这些是示例里为了聚焦主线而省略的):
- 初始化库存要和"活动开始"解耦:通常在活动开始前预热,避开零点
- 库存 key 使用 noeviction 策略,避免被 LRU 淘汰
- Redis Cluster + hash tag,保证同一商品的多 key 同 slot
- 扣减失败要区分"库存不足"和"系统异常",只有前者返回"已售罄"
- 扣减成功后异步把消息发到 MQ,由消费者落 MySQL
最后这一条最关键:Redis 扣减成功不等于订单创建成功。 预扣和落库之间隔着一条消息链路,Redis 里的库存扣了,MySQL 里的订单可能还没建。这正是第 6 章要解决的最终一致性问题。
这一页把 Redis 扣库存的实现讲完了。接下来的三个问题,正好对应”上线之后最常被问到的三件事”。
问题 1:Redis扣减后,数据库库存怎么办?
提示:
- Redis只扣了内存中的库存
- 数据库的库存还没扣
- 如何保证Redis和数据库一致?
解题思路
先把角色定清楚:Redis 是”预扣层”,MySQL 是”事实来源”。同步方案的设计由这个角色划分决定,而不是由”哪个更实时”决定。
详细步骤
-
谁是事实来源:MySQL 里存着订单和成交记录,它是业务事实的最终来源;Redis 里的库存是可被重建的加速副本。所以实时同步的方向是 Redis 到 MySQL。
-
主链路:异步消息队列
Redis 扣减成功 ↓ 发送消息(带上订单号、商品、数量) ↓ 消费者收到 → 扣 MySQL 库存 + 创建订单 ↓ 返回用户"抢购成功"Redis 扣减完就立刻返回,主链路的延迟被压到最低。
-
消费端必须幂等:消费者可能因为网络抖动、重启而重复消费。用订单号做幂等键,靠唯一索引在同一个事务里保证——重复消费时 INSERT 冲突、事务回滚,库存不会被扣第二次。
BEGIN INSERT INTO orders (order_id, ...) VALUES (...) -- 唯一索引 UPDATE product SET stock = stock - 1 WHERE id = ? AND stock >= 1 COMMIT -
MySQL 侧要自己再挡一次:
stock >= 1这个条件不能省。Redis 侧保证了不超卖,MySQL 侧也必须独立成立——任何依赖”上游一定是对的”的防线,在生产环境都会漏。 -
兜底:对账任务。定期比对”Redis 已扣减总量”和”MySQL 已售量”,差额就是需要修复的部分。它独立于同步链路,主链路全挂了也能跑。
-
诚实地说出代价:这段窗口里两边是不一致的。这不是缺陷,是刻意的取舍——强一致要跨系统两阶段提交,QPS 会直接掉回数据库水平。
最终答案
Redis 扣减成功后发消息到 MQ,消费者幂等地扣 MySQL 并建订单,再由独立的对账任务兜底。接受最终一致性,用”幂等 + stock >= 1 条件更新 + 对账”三道防线保证收敛。详见第 6.1、6.2、6.3 节。
问题 2:Redis崩溃了怎么办?
提示:
- Redis数据在内存中
- 如果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 并对账修复差异。
问题 3:如何处理用户退款?
提示:
- 用户购买后可能退款
- 退款需要回补库存
- 如何保证原子性?
解题思路
退款回补是”反向扣减”,比正向扣减更容易出错,核心风险是重复回补导致超卖。所以答案的重点不在”怎么加回去”,而在”怎么保证只加回去一次”。
详细步骤
-
回补必须原子:同样用 Lua 脚本执行
INCRBY,不能客户端 GET + INCR。回补是超卖的高发点——重复回补一次,就凭空多出一件可售商品。 -
回补必须幂等:用订单号做幂等键,同一笔订单只能回补一次。
回补前:检查 order.status != REFUNDED 回补:INCRBY stock 1 更新订单状态为 REFUNDED为什么必须幂等:用户可以重复点”申请退款”、客服可以重复点”确认退款”、超时扫描任务可能重复执行。这三个入口都会导致重复回补。
-
顺序也有讲究:先改订单状态再回补库存,还是反过来?
先改状态 → 中途崩溃 → 订单已退款但库存没补 → 少卖(可接受,对账能修) 先回补 → 中途崩溃 → 库存补了但订单还挂着 → 可售量虚增 → 超卖风险(不可接受)所以要先改订单状态。 在两个系统之间做不了同一个事务时,顺序的选择就是一道防线。
-
回补上限检查:脚本里要判断回补后不会超过初始库存:
if tonumber(stock) + tonumber(ARGV[1]) > tonumber(ARGV[2]) then return 0 -- 超过初始库存,拒绝回补 end多次重复的回补即使幂等键失效,也能被这个上限挡住。
-
口径要设计清楚:MySQL 侧不要简单地把
stock加回去。更清晰的做法是把库存口径拆开:total_stock 初始库存 sold_count 已售出 reserved 待支付占用 returned 已退款回补退款记在
returned上而不是直接改stock,这样”已售多少”和”可售多少”两个概念不会互相污染,对账公式也清晰。 -
两边都要回补:Redis 立刻恢复可售量(用户马上能再抢),MySQL 侧记录退款(账目准确)。两边各自回补,正好也是第 6 章说的”每道防线都要独立成立”。
-
已发货的订单不能回补可售库存:货已经发出去了,回补可售库存等于凭空多卖一件。这种情况要走”退货入库”流程,等实物回到仓库再回补。
最终答案
用 Lua 脚本原子回补 + 订单号做幂等键 + 先改订单状态后回补 + 脚本内做上限检查 + MySQL 侧用 returned 字段单独记账而不是直接改 stock。Redis 和 MySQL 两边各自回补,对账做最终兜底。
发现内容有问题?
告诉我们哪里需要改进。
