Redis预扣:使用Redis原子操作预扣库存

问题:数据库扛不住了,怎么办?🆘

上一章我们发现:

数据库锁方案性能:
- 悲观锁:1,000-5,000 QPS
- 乐观锁:5,000-20,000 QPS

秒杀需求:
- QPS:500,000+
- 差距:25-500倍!

核心问题:数据库是磁盘存储,I/O速度慢,无法支撑高并发。

解决思路:用内存数据库Redis替代MySQL!

Redis为什么这么快?⚡

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原子操作:库存扣减的核心 🎯

把库存放进 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

三个设计要点:

  1. 判断在扣减之前。 库存不够时直接返回 0,不执行 DECRBY。库存值永远不会被扣成负数,也不需要任何”补回来”的补救逻辑。
  2. 返回码要能区分失败原因。 1 / 0 / -1 分别代表成功、库存不足、key 未初始化。调用方拿到 0 就返回”已售罄”,拿到 -1 应该报警——这是配置错误,不是正常业务结果。
  3. 脚本要短。 脚本执行期间会阻塞这个实例上的所有其他请求。绝不能在里面写循环、不能做 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 vs Lua脚本 ⚖️

维度DECR + 手动回补DECR 裸用Lua 脚本
原子性❌ DECR 和 INCR 之间有间隙✅ 单命令原子✅ 整个脚本原子
库存会不会变负❌ 会,需要回补❌ 会✅ 不会
超卖风险❌ 有(回补次数错乱就会超卖)❌ 有✅ 无
网络往返2 次(DECR + INCR)1 次1 次
失败信息粗(只知道减了)粗(负数含义不明确)细(能区分不足/未初始化)
逻辑位置分散在客户端各处客户端收敛在服务端一处
维护成本高(每个调用方都要写对)低但不安全低(逻辑只有一份)
适用不推荐用于库存纯计数、允许出错的场景库存扣减等强一致要求场景

三个最关键的差别:

  1. 原子性。 DECR 单独用是原子的,但”减 + 判断 + 回补”这个组合不是。Lua 脚本把组合变成了一个原子单元。
  2. 库存语义。 库存是不能为负的业务字段,不是普通计数器。DECR 裸用会让它变成 -1、-2,破坏”库存值 = 可售数量”这个不变量。Lua 脚本在扣减前判断,保证库存永远是一个诚实的数字。
  3. 逻辑收敛。 用 Lua 之后,“怎么扣”这个规则只存在于一份脚本里,客户端不需要各自实现一遍。规则的唯一性比规则的执行速度更重要——一旦有第二个调用方写错了回补逻辑,超卖就来了。

什么时候 DECR 就够了:如果你的场景允许最终少算、允许负数(比如统计 PV、限流计数器),那 DECR 足够,而且更快。但库存不是这种场景。

性能测试:Redis vs MySQL ⚡

把三种方案放在同一台机器上压测,差距非常明显:

方案峰值 QPS平均响应说明
MySQL 悲观锁1,000-5,00010-500ms同一行上串行,连接池被等待请求占满
MySQL 乐观锁5,000-20,0001-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 的前提。

完整示例:Redis库存扣减系统 🎯

把前面的东西组装成一个能跑的最小系统。

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")}')

几个必须注意的实现细节:

  1. 回补库存也要用脚本。 release 里的 INCRBY 同样放在 Lua 里执行,保证”回补”和”读取剩余量”是一个原子动作。回补是超卖的高发点——重复回补一次,就凭空多出一件可售商品。
  2. stock:deducted:{id} 这个计数器是给对账用的。 它记录”Redis 一共扣了多少”,对账时拿它和 MySQL 的已售量比对,差额就是需要修复的部分。把它放进同一个 Lua 脚本一起更新,否则扣减成功但计数失败,账就永远对不上。
  3. 释放库存必须幂等。 超时释放的定时任务可能重复执行,必须用订单号做幂等键,否则会重复回补导致超卖。
  4. 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 是”事实来源”。同步方案的设计由这个角色划分决定,而不是由”哪个更实时”决定。

详细步骤

  1. 谁是事实来源:MySQL 里存着订单和成交记录,它是业务事实的最终来源;Redis 里的库存是可被重建的加速副本。所以实时同步的方向是 Redis 到 MySQL。

  2. 主链路:异步消息队列

    Redis 扣减成功
          ↓
    发送消息(带上订单号、商品、数量)
          ↓
    消费者收到 → 扣 MySQL 库存 + 创建订单
          ↓
    返回用户"抢购成功"

    Redis 扣减完就立刻返回,主链路的延迟被压到最低。

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

    BEGIN
      INSERT INTO orders (order_id, ...) VALUES (...)   -- 唯一索引
      UPDATE product SET stock = stock - 1 WHERE id = ? AND stock >= 1
    COMMIT
  4. MySQL 侧要自己再挡一次:stock >= 1 这个条件不能省。Redis 侧保证了不超卖,MySQL 侧也必须独立成立——任何依赖”上游一定是对的”的防线,在生产环境都会漏。

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

  6. 诚实地说出代价:这段窗口里两边是不一致的。这不是缺陷,是刻意的取舍——强一致要跨系统两阶段提交,QPS 会直接掉回数据库水平。

最终答案

Redis 扣减成功后发消息到 MQ,消费者幂等地扣 MySQL 并建订单,再由独立的对账任务兜底。接受最终一致性,用”幂等 + stock >= 1 条件更新 + 对账”三道防线保证收敛。详见第 6.1、6.2、6.3 节。

问题 2:Redis崩溃了怎么办?

提示:

  • Redis数据在内存中
  • 如果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 并对账修复差异。

问题 3:如何处理用户退款?

提示:

  • 用户购买后可能退款
  • 退款需要回补库存
  • 如何保证原子性?
库存回补幂等一致性秒杀架构

解题思路

退款回补是”反向扣减”,比正向扣减更容易出错,核心风险是重复回补导致超卖。所以答案的重点不在”怎么加回去”,而在”怎么保证只加回去一次”。

详细步骤

  1. 回补必须原子:同样用 Lua 脚本执行 INCRBY,不能客户端 GET + INCR。回补是超卖的高发点——重复回补一次,就凭空多出一件可售商品。

  2. 回补必须幂等:用订单号做幂等键,同一笔订单只能回补一次。

    回补前:检查 order.status != REFUNDED
    回补:INCRBY stock 1
    更新订单状态为 REFUNDED

    为什么必须幂等:用户可以重复点”申请退款”、客服可以重复点”确认退款”、超时扫描任务可能重复执行。这三个入口都会导致重复回补。

  3. 顺序也有讲究:先改订单状态再回补库存,还是反过来?

    先改状态 → 中途崩溃 → 订单已退款但库存没补 → 少卖(可接受,对账能修)
    先回补   → 中途崩溃 → 库存补了但订单还挂着 → 可售量虚增 → 超卖风险(不可接受)

    所以要先改订单状态。 在两个系统之间做不了同一个事务时,顺序的选择就是一道防线。

  4. 回补上限检查:脚本里要判断回补后不会超过初始库存:

    if tonumber(stock) + tonumber(ARGV[1]) > tonumber(ARGV[2]) then
      return 0   -- 超过初始库存,拒绝回补
    end

    多次重复的回补即使幂等键失效,也能被这个上限挡住。

  5. 口径要设计清楚:MySQL 侧不要简单地把 stock 加回去。更清晰的做法是把库存口径拆开:

    total_stock   初始库存
    sold_count    已售出
    reserved      待支付占用
    returned      已退款回补

    退款记在 returned 上而不是直接改 stock,这样”已售多少”和”可售多少”两个概念不会互相污染,对账公式也清晰。

  6. 两边都要回补:Redis 立刻恢复可售量(用户马上能再抢),MySQL 侧记录退款(账目准确)。两边各自回补,正好也是第 6 章说的”每道防线都要独立成立”。

  7. 已发货的订单不能回补可售库存:货已经发出去了,回补可售库存等于凭空多卖一件。这种情况要走”退货入库”流程,等实物回到仓库再回补。

最终答案

用 Lua 脚本原子回补 + 订单号做幂等键 + 先改订单状态后回补 + 脚本内做上限检查 + MySQL 侧用 returned 字段单独记账而不是直接改 stock。Redis 和 MySQL 两边各自回补,对账做最终兜底。

发现内容有问题?

告诉我们哪里需要改进。