队列串行:使用消息队列串行处理请求
上一节我们学会了用Redis原子操作扣减库存:
新的问题出现了:
场景:用户购买成功
1. Redis扣减库存:stock = 100 → 99 ✅
2. 创建订单:需要写入MySQL ❌
3. 扣减MySQL库存:stock = 100 → 99 ❌
问题:
- 如果直接操作MySQL,又会回到数据库瓶颈
- 如果不操作MySQL,Redis和MySQL数据不一致
- 如何在保证性能的同时,完成数据库操作?
解决思路:使用消息队列!
上一节把”判断库存并扣减”这个动作搬到了 Redis,本节要搬走的是”创建订单”这个动作。队列的作用,就是给 Redis 和 MySQL 之间加一道缓冲。
消息队列(Message Queue)是一个进程间的通信中间件:生产者把消息放进队列,消费者按自己的节奏取走,双方互不感知对方的存在。
生产者 消息队列 消费者
(秒杀服务) (Redis List) (订单服务)
│ │ │
│ LPUSH order:queue │ │
├─────────────────────────▶│ │
│ │ BRPOP order:queue │
│ │◀─────────────────────────┤
│ │─────────────────────────▶│
它给系统带来三个能力:
| 能力 | 含义 | 在秒杀里的价值 |
|---|---|---|
| 解耦 | 生产者不需要知道谁在消费、消费要多久 | 秒杀服务和订单服务可以独立部署、独立扩容 |
| 异步 | 生产者发完消息立刻返回,不用等结果 | 用户不必等数据库写完才拿到响应 |
| 削峰 | 突发流量先堆在队列里,消费端按能力慢慢处理 | 数据库只面对它能承受的写入速率 |
为什么必须引入它
把三种做法放在一起对比,差别就清楚了:
| 方案 | 生产者做什么 | 消费端压力 | 失败影响 | 一致性窗口 |
|---|---|---|---|---|
| 直接调用 | 同步等数据库写完 | 与入口同量级,50 万 QPS 打库 | 当场失败,用户可见 | 无(当场确定) |
| 线程池 | 提交任务后不等 | 仍受队列长度限制,线程池满则拒绝 | 任务可能丢失 | 秒级 |
| 消息队列 | 投递消息即返回 | 由消费者数量和速度决定 | 转成后台重试 | 秒到分钟级 |
直接调用的致命之处在于:生产者被消费端的速度绑架了。 50 万 QPS 的入口,配上 1 万 QPS 的数据库,结果是 49 万 QPS 的请求在数据库连接池上排队、超时、重试,把数据库彻底压垮。引入队列之后,生产者只需要面对队列的写入速度(Redis 的量级),消费端只需要面对自己的处理能力。
投递语义:为什么一定会重复
队列的语义有三种,而生产系统实际能做到的只有一种:
| 语义 | 含义 | 现实 |
|---|---|---|
| at-most-once | 最多一次,可能丢 | 可以做到,但会丢单 |
| at-least-once | 至少一次,可能重 | 消息队列的默认语义 |
| exactly-once | 恰好一次 | 跨系统代价极高,基本做不到 |
“可能重”不是缺陷,是分布式系统的常态:消费者处理完、还没来得及 ACK 就断电了,消息只能被重新投递。所以队列系统必须配套两个机制——幂等和重试。这正是下一页要展开的内容。
为什么用 Redis List
业界的消息队列有 Kafka、RocketMQ、RabbitMQ。这一页用 Redis List,因为它在我们已有的技术栈里,而且它具备演示队列全部语义所需的能力:
LPUSH/BRPOP是原子命令,不需要额外的客户端锁;BRPOP是阻塞的,没有消息时挂起连接,不产生空转轮询;- Redis 本身就有主从、集群和持久化能力,运维成本几乎为零。
生产环境的选型要看消息规模、吞吐、持久化要求和运维成本,而不是看哪个名字更响。
方案架构
生产者(秒杀服务,10 个实例并发写)
│ LPUSH order:queue:{1001}
▼
┌──────────────────────────────────────────┐
│ Redis List:order:queue:{1001} │
│ 队头 ← LPUSH 入队 │
│ 队尾 ← BRPOP 出队 │
│ 语义:先进先出(FIFO) │
└──────────────────────────────────────────┘
│ BRPOP(阻塞,5 秒超时)
┌────┴────────┬──────────────┐
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌────────┐
│消费者 1 │ │消费者 2 │ │消费者 N │ ← 竞争消费
└────┬───┘ └────┬───┘ └────┬───┘ 一条消息只被其中一个取走
│ │ │
└───────────┴────────────┘
▼
MySQL:写订单 + 扣库存
几个关键设计
1. 方向:LPUSH + BRPOP,或 RPUSH + BLPOP
两种组合都是 FIFO,选哪种都行,但两个命令必须配套且方向相反:
LPUSH + BRPOP → 左进右出 = FIFO ✅
LPUSH + BLPOP → 左进左出 = LIFO ❌ 后面的请求先被处理
RPUSH + BRPOP → 右进右出 = LIFO ❌
2. 必须用阻塞命令,不能用两条命令拼
❌ 错误写法:
LPOP queue # 取出
... 处理 ...
LPUSH queue # 放回(处理失败时)
→ 两条命令之间如果进程崩溃,消息就永久丢失
→ 而且多个消费者会互相抢消息,顺序彻底乱了
✅ 正确写法:
BRPOP queue 5 # 原子地取出,没有消息时阻塞等待
3. 队列按活动隔离
不同场活动的流量不应该互相干扰:
order:queue:{1001} 活动 1001 的下单队列
order:queue:{1002} 活动 1002 的下单队列
order:dead:{1001} 活动 1001 的死信队列
order:processing:{1001} 活动 1001 的处理中队列
用 hash tag 包裹活动 ID({1001}),是为了在 Redis 集群下让同一活动的多个 key 落在同一个 slot——后面 Lua 脚本要同时操作它们,跨槽会直接报错。
4. 消息体要小
消息体只放消费者真正需要的字段:
{"order_id":"A202410110001","user_id":9527,"product_id":1001,"quantity":1,"ts":1731273600000}
不塞商品名称、图片 URL、活动规则这些消费者用不到的东西。每条消息多 100 字节,一百万条积压就是多 100MB 内存。
5. 队列长度必须监控
LLEN order:queue:{1001} 是最直接的健康指标,它同时也是容量预警的信号。
方案落地
生产者:投递
import json
QUEUE_KEY = 'order:queue:{1001}'
def enqueue_order(order: dict) -> int:
"""投递一条下单消息,返回投递后的队列长度"""
payload = json.dumps(order, ensure_ascii=False, separators=(',', ':'))
return r.lpush(QUEUE_KEY, payload)
生产者在扣减库存成功之后才投递消息。顺序反了就会出现”有订单但没扣库存”,那是最危险的一种错误。
更稳妥的做法:把扣减和投递放进同一个 Lua 脚本(见 4.3 节的
deduct_and_enqueue.lua),彻底消除两步之间的窗口。
消费者:取与处理
def consume_forever(queue_key: str = QUEUE_KEY):
while True:
# BRPOP:队列为空时阻塞等待,最多等 timeout 秒
raw = r.brpop(queue_key, timeout=5)
if raw is None:
continue # 超时了,重新阻塞即可
msg = json.loads(raw)
try:
create_order(msg) # 写 MySQL:插订单 + 扣库存
except Exception:
schedule_retry(raw, msg) # 失败重试(4.3 节详解)
continue
# 处理成功,消息自然出队,无需额外 ACK
用 BRPOP 取出消息,就意味着消息在弹出的一瞬间就”离开”了队列。 这带来一个致命问题:如果消费者在处理过程中崩溃,这条消息既不在队列里,也没有处理成功——它丢了。
解决办法是处理中队列,下一页会详细展开:
BRPOPLPUSH order:queue:{1001} order:processing:{1001}
→ 原子地把消息从队列挪到处理中队列
→ 处理成功后从处理中队列删除(ACK)
→ 消费者崩溃后,处理中队列里的残留消息可以被重新捞回来
Redis 的可靠性配置
队列能不能扛住故障,一半取决于 Redis 的配置:
# 持久化:消息落盘,Redis 重启不丢
appendonly yes
appendfsync everysec
# 淘汰策略:绝不能淘汰队列 key
maxmemory-policy noeviction
maxmemory-policy noeviction 这一条尤其关键。 如果开了 allkeys-lru,Redis 内存吃紧时会主动淘汰 key——而队列 key 在 LRU 眼里就是”很久没被访问的冷数据”(消费者不取它的时候它就是冷的),于是它会在毫不知情的情况下被删掉。那才是真正意义上的静默丢单,而且没有任何报错。
同理,队列所在的 Redis 实例必须有独立的内存配额,不要和缓存业务混用,否则缓存的波动会把队列挤掉。
几个容易踩的坑
| 坑 | 表现 | 做法 |
|---|---|---|
| 阻塞连接被复用 | BRPOP 阻塞期间连接超时,抛异常 | 消费者用独立连接池,阻塞操作独占一条连接 |
| 超时时间设成 0 | 永不返回,进程无法优雅退出 | 设 1-5 秒的超时,循环里重新阻塞 |
| 消费者数量超过队列长度 | 多出来的消费者空转,白占连接 | 消费者数量按队列长度和 DB 能力动态调整 |
| 队列无限增长 | Redis 内存打满 | 监控 LLEN,超阈值触发降级或限流 |
| 消息体塞太多字段 | 内存翻倍,序列化变慢 | 只放消费端需要的字段 |
削峰填谷是队列最经典的用途,用图看最清楚:
请求速率(QPS)
^
| 峰值 500,000
| /\
| / \
| / \
|_____________________/ \___________________
| 消费能力 5,000 ──────────────────────
+----------------------------------------------------> 时间
-10s 0s +3s +5min
流量在 3 秒内冲到 50 万 QPS,而消费者只能以 5,000 QPS 的速度处理。中间的差值不会消失,它会变成队列里的积压。
积压量怎么算
积压消息数 ≈ 峰值持续时间 × (峰值速率 - 消费速率)
50 万 QPS 峰值持续 3 秒,消费能力 5,000 QPS:
积压 = 3 × (500,000 - 5,000) = 1,485,000 条
这 149 万条消息,每条按 200 字节算:
1,485,000 × 200B ≈ 297 MB
这就是队列内存必须提前算的原因。 一个 100 件库存的秒杀活动,队列里可能堆着上百万条请求消息——大部分注定是抢不到的。如果没提前预留内存,Redis 会先于数据库被打爆。
填谷:队列的另一面
削峰是把高峰”削”平,填谷则是让低谷时段把队列消化掉。
高峰(0-3秒) 积压 149 万条
低谷(3秒-5分钟) 消费者按 5,000 QPS 慢慢消化
消化完需要: 1,485,000 ÷ 5,000 ≈ 297 秒 ≈ 5 分钟
5 分钟用户拿不到结果,秒杀就失去了意义。 所以队列不是无限的,它是一个有容量、有延迟代价的缓冲区:
入口流量 50 万 QPS
↓ 队列缓冲(削峰)
消费能力 5,000 QPS
↓ 决定用户等待时长的,是「积压量 ÷ 消费速率」
最终结果:用户最长等 5 分钟
排队系统(第 5 章)解决的正是这个问题:它在入口处按一个受控的速率放行,让进到队列里的消息量恰好等于消费能力,队列从一开始就不会堆积。用户等的时间,从 5 分钟降到几秒。
削峰填谷的收益与代价
| 维度 | 收益 | 代价 |
|---|---|---|
| 数据库 | 只面对 5,000 QPS 的写入,不再被打挂 | 消费速度受限于 DB,要靠加机器提 |
| 用户 | 拿到的是”处理中”,而不是超时 | 要等结果,体验需要设计 |
| 系统 | 故障被隔离在队列后面 | 队列挂了、内存不足,都要单独处理 |
| 数据 | — | 存在不一致窗口,需要对账兜底 |
队列把”扛不住流量”变成了”处理得慢”。 慢可以优化,可以扩容,可以慢慢来;扛不住只能宕机。
队列里有了消息,怎么消费决定了系统的吞吐和正确性。几种常见策略:
| 策略 | 做法 | 适用场景 | 风险 |
|---|---|---|---|
| 单消费者串行 | 一个进程从头消费到尾 | 顺序敏感、吞吐要求低 | 积压快 |
| 多消费者竞争 | 多个进程抢同一队列,谁抢到谁处理 | 订单创建这类无序要求的高吞吐场景 | 顺序不保证 |
| 广播消费 | 每个消费者都收到全量消息 | 缓存刷新、索引重建 | 重复放大 |
| 批量拉取 | 一次取 N 条批量处理 | 减少网络往返、提升吞吐 | 延迟变差 |
秒杀的下单消息适合多消费者竞争:每条订单是独立的,谁先处理谁处理,不需要保证全局顺序。
三个必须知道的语义
1. 竞争消费:一条消息只会被一个消费者处理
队列:[m1, m2, m3]
消费者 A 取走 m1
消费者 B 取走 m2
消费者 C 取走 m3
→ 三条消息各被处理一次,不会重复
2. 顺序只在单队列单消费者内成立
一旦有多个消费者,Redis List 的 FIFO 只保证”出队顺序”,不保证”完成顺序”。消费者 A 拿到 m1 慢一点,消费者 B 拿到 m2 先完成——完成顺序就乱了。
对订单创建来说这通常没问题(订单之间没有依赖)。但如果有依赖(比如”创建订单”必须在”扣库存”之前),就必须用分区队列:按某个键(比如用户 ID 或商品 ID)做哈希,同一个键的消息固定进同一个队列,由同一个消费者按序处理。
3. ACK 的位置决定可靠性
❌ 取出即视为成功(相当于 at-most-once)
→ 处理中崩溃,消息永久丢失
✅ 处理成功后再确认(at-least-once)
→ 处理中崩溃,消息会被重新投递
→ 代价是可能重复,所以必须幂等
多消费者实现
多消费者的实现其实非常简单——多个进程连同一个 Redis,各自阻塞弹出就行,Redis 保证一条消息只会被其中一个取走。
# consumer_worker.py
import json
import os
import signal
import time
WORKER_ID = os.getenv('WORKER_ID', 'worker-1')
QUEUE_KEY = 'order:queue:{1001}'
PROCESSING_KEY = 'order:processing:{1001}'
running = True
def stop(signum, frame):
global running
running = False
signal.signal(signal.SIGTERM, stop)
def consume_forever():
while running:
# 原子地把消息挪到处理中队列
raw = r.brpoplpush(QUEUE_KEY, PROCESSING_KEY, timeout=5)
if raw is None:
continue
msg = json.loads(raw)
try:
create_order(msg)
except Exception:
schedule_retry(raw, msg)
continue
# 处理成功 → ACK(从处理中队列移除)
r.lrem(PROCESSING_KEY, 1, raw)
print(f'[{WORKER_ID}] 订单 {msg["order_id"]} 创建成功')
启动多个实例即可:
worker-1 → 消费者 1
worker-2 → 消费者 2
...
worker-20 → 消费者 20
启动时的崩溃恢复
消费者重启后,先把处理中队列里的残留消息捞回来:
def recover_stale_messages(queue_key: str, processing_key: str) -> int:
"""把处理中队列里的残留消息重新放回主队列"""
recovered = 0
while True:
raw = r.rpoplpush(processing_key, queue_key) # 原子地挪回主队列
if raw is None:
break
recovered += 1
return recovered
这一步是”消息不丢”的关键。 没有它,处理中崩溃的消息就永远卡在处理中队列里,用户既没有订单也没有任何提示。
消费者数量怎么定
消费者数量不是越多越好,它有一个硬上限:
消费能力 = 消费者数量 × 单条处理耗时(的倒数)
20 个消费者 × 单条 10ms → 2,000 QPS
50 个消费者 × 单条 10ms → 5,000 QPS
上限由 MySQL 的写入能力决定,而不是由消费者数量决定。 消费者超过数据库能承受的并发之后,多出来的消费者只会加剧数据库的锁竞争,把吞吐打下来。
而且这里还有一个约束:如果消息本身是有序的(同一个用户或同一个商品的消息需要串行处理),那消费者数量必须等于分区数,再多也没用——这就是分区队列的代价。
消费能力的监控
LLEN order:queue:{1001} 队列积压长度
消费速率(每秒成功处理条数) 消费者健康度
消息驻留时间 P99 用户实际等待时间
重试率 / 死信长度 失败情况
这四个指标要放在同一张看板上。 队列长度单独看没有意义——它大可能是在稳定消化,也可能是完全卡死,要结合消费速率一起判断。
同一场活动(库存 100 件,50 万人抢),两种架构的对比:
| 指标 | 同步直写 MySQL | 队列异步 |
|---|---|---|
| 入口峰值 QPS | 50 万(全部打到数据库) | 50 万打到 Redis |
| 数据库峰值写 QPS | 50 万 ❌ | 5,000(等于消费者能力) |
| 系统实际吞吐 | 5,000-20,000 QPS(受 DB 限制) | 100,000+ QPS(受 Redis 限制) |
| 用户 P99 延迟 | 300-800ms,失败时超时 | 5-15ms 返回”处理中” |
| 数据库被打挂的后果 | 整场活动失败,不可恢复 | 队列缓冲,数据库只处理成功请求 |
| 单条消息失败的影响 | 当场失败,用户直接看到错误 | 转成后台重试,用户无感 |
| 额外成本 | 无 | 队列内存、消费者机器、重试与幂等代码 |
| 数据一致性 | 当场确定 | 秒级窗口,需要对账 |
最关键的一行是”数据库被打挂的后果”。 同步架构下,数据库一挂就是整场活动失败,没有补救余地;队列架构下,数据库挂了只会让消费变慢,队列还在,数据库恢复后消息继续被消费——故障半径被队列缩小了一个数量级。
同样重要的是”单条消息失败的影响”。同步架构里,一条消息失败就是一次用户可见的失败;异步架构里,它变成一次后台重试,用户看到的只是”处理中”多持续了几秒。故障从用户的感知里消失了。
什么时候不该用队列
队列不是万能的,以下场景用队列反而是负担:
| 场景 | 原因 |
|---|---|
| 低并发、必须立刻拿到结果 | 队列只会增加延迟 |
| 强顺序依赖且无法分区 | 队列会破坏顺序保证 |
| 单条业务逻辑极简单 | 引入中间件的复杂度大于收益 |
| 需要用户立刻知道成败 | 异步通知的复杂度高于直接返回 |
秒杀的场景恰好全部落在”该用队列”的那一侧:高并发、可以接受最终结果、单条逻辑不复杂、用户能接受”处理中”。第 1 章的”关键取舍”里说”异步排队能削峰,但用户要等待结果”——这一页就是在回答”这个取舍值得吗”。
问题 1:队列满了怎么办?
提示:
- 队列容量有限
- 用户持续下单
- 如何处理队列溢出?
解题思路
队列满了说明两件事同时发生:流量超过消费能力,而且缓冲区已经用完。这时候必须做取舍——要么让一部分请求失败(保护系统),要么让系统被压垮(谁都不想要)。没有第三条路,所以先要想清楚”宁可丢什么”。
详细步骤
-
先算容量,而不是等它满。队列内存 ≈ 峰值积压条数 × 单条消息字节数。提前按上一节的算例把内存配额留出来,比事后处理便宜得多。Redis 实例要有独立配额,不要和缓存混用。
-
设置硬上限并主动拒绝。用
LLEN配合阈值做判断:
MAX_QUEUE_LEN = 200_000 # 提前算好的上限
if r.llen(QUEUE_KEY) > MAX_QUEUE_LEN:
return 'BUSY' # 明确拒绝:系统繁忙,请稍后再试主动拒绝比静默丢弃好一万倍。 静默丢弃会让用户以为”我抢到了”却永远等不到结果;明确拒绝至少让用户知道发生了什么。
-
拒绝的顺序:先拒无效的,再拒有效的。队列快满时,优先挡掉”明显抢不到”的请求(库存已为 0、重复提交、已中过奖的用户),保留真正有机会的请求。这比一刀切地按先到先拒要公平得多。
-
配合上游限流。队列满的根因是入口流量超过消费能力,解法在入口而不是队列——第 5 章的限流和排队系统就是干这个的。队列是最后一道防线,不是唯一一道防线。
-
消费者侧加速。紧急时可以临时扩容消费者、增加单批处理条数,让积压尽快下去。但要记住消费能力的上限是数据库写入能力,加消费者超过这个点只会加剧锁竞争。
-
极端情况直接熔断。如果连 Redis 内存都快不够了(队列本身要占内存),要能立刻切换到”直接拒绝 + 提示稍后再来”的降级模式,保住活动页面和已成功的订单。
最终答案
队列满时必须主动、快速、可解释地拒绝,并按”先拒无效请求、再拒有效请求”的顺序处理;同时在入口用限流和排队把流量削到消费能力以内,让队列根本不发生溢出。队列内存必须提前算、提前留配额,并和缓存业务物理隔离。
问题 2:消费者挂了怎么办?
提示:
- 消费者处理订单时崩溃
- 队列中的消息还在吗?
- 如何保证消息不丢失?
解题思路
“消费者挂了”要拆成两个完全不同的问题:崩溃时消息还在不在队列里(取决于用的是什么弹出命令),以及消息在但会不会被重复处理(取决于幂等)。前者是可用性问题,后者是正确性问题。
详细步骤
-
先确认弹出方式。用
BRPOP(或LPOP)弹出,消息在弹出的瞬间就离开了队列——消费者此刻崩溃,消息永久丢失。这是最危险的一种实现。 -
改用”处理中队列”。用
BRPOPLPUSH原子地把消息从主队列挪到处理中队列:
主队列 [m1, m2, m3]
→ BRPOPLPUSH 取出 m1
主队列 [m2, m3] 处理中队列 [m1]- 崩溃后的恢复:消费者重启时,先扫描处理中队列,把残留消息挪回主队列:
while True:
raw = r.rpoplpush(PROCESSING_KEY, QUEUE_KEY)
if raw is None:
break这一步必须在消费者开始处理新消息之前执行,否则新消息会插到旧消息前面,顺序就乱了。
-
处理成功后再 ACK:从处理中队列删除消息,才是真正的”确认完成”。顺序是”处理 → 提交 → 删除”,任何一步崩溃,消息都会留在处理中队列里等待重投。
-
重复处理是必然的,必须幂等。消息被重新投递后,第二次处理必须产生和第一次相同的结果。落地上就是:订单号唯一索引 + 幂等键(详见 4.3 节的「幂等性设计」)。没有幂等,崩溃恢复就会变成重复下单和重复扣库存。
-
优雅停机:收到 SIGTERM 后先停止取新消息,把手里的消息处理完再退出;退出前把处理中队列里的残留消息挪回主队列。避免每次发布都产生一批”卡在处理中队列”的消息。
最终答案
用 BRPOPLPUSH 把消息原子地挪到处理中队列,处理成功后再删除(ACK),消费者启动时先把处理中队列的残留消息挪回主队列。因为重投必然发生,消费端必须幂等——否则崩溃恢复会直接变成重复订单。
问题 3:如何保证Redis和MySQL的一致性?
提示:
- Redis扣减成功
- 队列写入成功
- MySQL操作失败怎么办?
解题思路
先看清楚这个场景的性质:Redis 扣减成功、消息也成功入队了,但消费端处理 MySQL 时失败了。这时候 Redis 少了一件可售库存,MySQL 里没有对应订单——少卖,不是超卖。因此要回答的问题是”怎么把多占的库存还回去”,而不是”怎么保证两边同时一致”。
详细步骤
- 失败要分类。不是所有失败都该重试:
| 失败类型 | 例子 | 处理 |
|---|---|---|
| 瞬时故障 | 连接超时、主从切换 | 指数退避后重试(4.3 节的「重试机制详解」) |
| 业务失败 | MySQL 库存不足、参数非法 | 不重试,直接走补偿 |
| 系统故障 | 代码 bug、数据格式错 | 有限次重试后进死信队列 + 告警 |
-
重试要能安全地重试。因为重投意味着同一条消息可能被处理多次,所以消费端必须幂等:订单号唯一索引 + 幂等标记(4.3 节)。先有幂等,再谈重试。
-
业务失败要走补偿:MySQL 库存不足,说明这次扣减不成立,必须把 Redis 的库存还回去,同时把订单标记为失败并通知用户。补偿动作本身要幂等——写成”设置成目标值”而不是”加 1”,重复执行才不会越补越多。
-
最终靠对账收敛。在线机制(重试、死信、补偿)都可能同时失效,所以要有一条独立的、不依赖同步链路的校验路径:
初始库存 = MySQL 已售 + MySQL 待支付占用 + Redis 剩余可售 + 异常差异差异里的”Redis 剩余偏多”就是这类场景,补回库存即可(第 6.2 节的「库存对账和数据修复机制」)。
- 一致性窗口要被监控。记录每个订单的”Redis 扣减时间”和”MySQL 提交时间”,窗口 P99 超过阈值就要告警。窗口突然拉长,往往意味着消费者变慢或队列积压。
最终答案
承认这是一个最终一致问题:Redis 已扣但订单没建成属于”少卖”,靠三层机制收敛——瞬时失败退避重试(靠幂等保证安全)、业务失败立即补偿回库存、最终由对账任务扫描差额补回。切忌在消费者失败时直接”把 Redis 加回去”,那样会把一个可恢复的失败变成超卖。
发现内容有问题?
告诉我们哪里需要改进。
