异步下单:异步处理订单提升吞吐量
前两节我们建立了完整的流程:
用户请求 → Redis扣减库存 → 写入队列 → 消费者处理 → 创建订单
但是有个新问题:
队列里的消息如果处理失败怎么办?用户已经收到”抢购成功”的提示,订单却根本没生成。消费者处理到一半崩溃,消息还在队列里吗?同一条消息被重复消费,会不会创建出两张订单?
场景:用户点击"抢购",Redis 扣减成功,消息已入队
↓
消费者取出消息,开始在 MySQL 里创建订单
↓
此刻消费者进程崩溃 / 数据库连接超时 / 机器被 kill
↓
结果:
· Redis 库存已经扣了,用户的抢购名额被占住
· MySQL 里没有这条订单
· 队列里那条消息处于未知状态(弹出了?还在?半处理?)
· 用户什么反馈都没收到
这个场景里的每一个问号,都要有人回答。这一页要解决的,就是这条异步链路上的全部可靠性问题:消息不能丢、处理不能重、结果要能送到用户手上。
异步下单不是”退而求其次”的替代方案,而是在 50 万 QPS 下唯一跑得通的形态。先算一笔账。
如果订单在用户请求里同步创建,每一个成功的请求都要在主链路上完成两次 MySQL 写:
用户请求 → Redis 扣库存 → MySQL 插订单 → MySQL 扣库存 → 返回给用户
└──────── 两次同步写 ────────┘
这两次写都在用户的等待路径上,耗时直接叠加;而每秒能完成多少次,受限于最慢的那一次写。第 3 章的结论是 MySQL 乐观锁只能撑到 5,000-20,000 QPS:
| 路径 | 主链路上的同步写 | 峰值吞吐 | 用户感知延迟 |
|---|---|---|---|
| 同步下单 | 插订单 + 扣库存(2 次 MySQL 写) | 5,000-20,000 QPS | 两次写耗时叠加,几百毫秒 |
| 异步下单 | 0 次(只做 Redis 扣减 + 入队) | 100,000+ QPS | 一次内存操作 + 一次入队,通常 10ms 以内 |
异步的本质,是把”能不能创建订单”从”用户请求的返回值”里摘出去。 Redis 扣减成功 = 获得了抢购资格;订单创建成功 = 资格兑现成订单。这是两件事,解耦之后,主链路的耗时被压缩到只剩下 Redis 操作。
上一页我们用队列把下单请求串行化了,解决了”数据库扛不住”的问题。这一页要解决的是队列带来的新问题:异步之后,可靠性要自己扛。
四个挑战:
| 挑战 | 具体表现 | 后果 | 应对机制 | 对应小节 |
|---|---|---|---|---|
| 消息可能丢 | 扣减成功后进程崩溃,消息从未入队 | 用户有资格却没订单,库存被占住 | 可靠入队 + 重试 + 对账兜底 | 重试机制详解 |
| 消息可能重复 | ACK 丢失、消费者重启重投 | 重复扣库存、生成重复订单 | 幂等键 + 唯一索引 | 幂等性设计 |
| 状态会短暂不一致 | Redis 已扣,MySQL 还没跟上 | 两边库存对不上 | 最终一致性 + 对账 | 最终一致性保证 |
| 用户要等结果 | 同步返回变成异步通知 | 用户不知道有没有抢到 | 订单查询 + 结果推送 | 想一想 问题 1 |
这四个挑战不是并列的,而是有依赖关系的:不解决重试,幂等无从谈起(消息会重复,正是因为重投机制在起作用);不解决幂等,重试就是灾难(重试会制造重复订单);不解决最终一致性,前面所有的努力都可能因为一次对不上而前功尽弃。
所以这一页的顺序是:架构 → 重试 → 幂等 → 一致性 → 收益。
方案架构
整条链路分成”同步主链路”和”异步链路”两段,分界线就是用户请求返回的那一刻。
┌────────────────────────────────────┐
用户请求 ────────▶ │ 秒杀服务(同步主链路) │
P99 < 10ms │ ① 限流 / 风控 / 排队校验(见第 5 章) │
│ ② Redis Lua:扣库存 + 入队(原子) │
│ ③ 返回「已排队,处理中」 │
└─────────────────┬──────────────────┘
│ 订单消息
▼
┌────────────────────────────────────┐
│ 消息队列(Redis List / Kafka) │
│ order:queue:{activityId} │
│ 持有:尚未落库的订单请求 │
└─────────────────┬──────────────────┘
│ BRPOP(竞争消费)
┌──────────────────────────┼──────────────────────────┐
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 消费者 #1 │ │ 消费者 #2 │ │ 消费者 #N │
│ 幂等校验 │ │ 幂等校验 │ │ 幂等校验 │
│ 建订单 │ │ 建订单 │ │ 建订单 │
│ 扣 MySQL 库存 │ │ 扣 MySQL 库存 │ │ 扣 MySQL 库存 │
│ ACK │ │ ACK │ │ ACK │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
└──────────────────────────┼──────────────────────────┘
▼
┌────────────────────────────────────┐
│ MySQL(业务事实来源) │
│ orders(唯一索引兜底幂等) │
│ product(条件更新兜底超卖) │
└─────────────────┬──────────────────┘
▼
┌────────────────────────────────────┐
│ 结果通知 │
│ 客户端轮询订单状态 / 服务端推送 │
└────────────────────────────────────┘
各组件的职责和关键要求:
| 组件 | 职责 | 关键要求 |
|---|---|---|
| 秒杀服务 | 同步判定资格、入队、立刻响应 | 扣减与入队必须在同一个原子操作里完成 |
| 消息队列 | 缓冲请求、削峰、解耦 | 消息要能持久化;容量和内存要算过 |
| 消费者 | 创建订单、扣减 MySQL 库存 | 必须幂等;处理成功后再 ACK |
| MySQL | 业务事实来源 | 订单号唯一索引 + 条件更新,两道防线独立成立 |
| 结果通知 | 把异步结果告诉用户 | 必须有查询兜底,不能只依赖推送 |
这张图里有三个”必须”,每一个都是后面小节的主题:
- 扣减和入队必须原子。 如果拆成两步——先扣库存再入队——中间崩溃就会凭空少一个订单。这正是 4.1 节 Lua 脚本的思路,这里把队列 key 也放进脚本。
- 消费必须幂等。 队列的语义是”至少一次投递”,重复是常态而不是意外。
- ACK 必须在业务处理成功之后。 先 ACK 再处理,等于把消息交给空气。
还要说清楚一件事:这套架构没有消除故障,只是把故障挪到了更可控的地方。 同步路径下,创建订单失败会立刻返回给用户;异步路径下,它变成一条失败的消息,需要重试、死信和对账来兜底。这个代价必须承认——异步不是免费的,它用工程复杂度换吞吐。
完整流程实现
五个环节,每个环节都有容易写错的地方。
第一步:原子扣减 + 入队(生产者)
生产端最容易犯的错,是把”扣库存”和”入队”写成两行代码:
# ❌ 错误写法:两步之间有窗口
if deduct_stock(stock_key, 1):
r.lpush(queue_key, message)
return SUCCESS
扣减成功 → 进程崩溃 → 消息从未入队
结果:库存被占住,订单永远不存在
正确做法是把两步放进同一个 Lua 脚本,和 4.1 节的扣减脚本是同一个思路:
-- deduct_and_enqueue.lua
-- KEYS[1]: 库存 key 例:stock:1001
-- KEYS[2]: 队列 key 例:order:queue:{1001}
-- KEYS[3]: 用户已购标记 key 例:bought:{user_9527}
-- ARGV[1]: 购买数量
-- ARGV[2]: 订单号(全局唯一,幂等键)
-- ARGV[3]: 用户 ID
-- ARGV[4]: 商品 ID
-- ARGV[5]: 时间戳(客户端生成)
-- 返回:1 成功 / 0 库存不足 / -1 已抢过 / -2 key 不存在
local stock = redis.call('GET', KEYS[1])
if not stock then
return -2
end
if tonumber(stock) < tonumber(ARGV[1]) then
return 0
end
-- 同一用户只能中一次(防重复提交)
if redis.call('EXISTS', KEYS[3]) == 1 then
return -1
end
redis.call('DECRBY', KEYS[1], ARGV[1])
redis.call('SET', KEYS[3], 1, 'EX', 3600)
local msg = cjson.encode({
order_id = ARGV[2],
user_id = ARGV[3],
product_id = ARGV[4],
quantity = tonumber(ARGV[1]),
timestamp = ARGV[5]
})
redis.call('LPUSH', KEYS[2], msg)
return 1
调用方:
DEDUCT_ENQUEUE_SHA = r.script_load(DEDUCT_ENQUEUE_SCRIPT)
def try_buy(activity_id: str, product_id: str, user_id: str, order_id: str) -> str:
stock_key = f'stock:{product_id}'
queue_key = f'order:queue:{{{activity_id}}}' # hash tag 保证同槽
bought_key = f'bought:{{{user_id}}}'
try:
code = r.evalsha(
DEDUCT_ENQUEUE_SHA, 3,
stock_key, queue_key, bought_key,
1, order_id, user_id, product_id, int(time.time() * 1000),
)
except redis.exceptions.NoScriptError:
# 脚本被 flush 或 Redis 重启了,重新加载一次
global DEDUCT_ENQUEUE_SHA
DEDUCT_ENQUEUE_SHA = r.script_load(DEDUCT_ENQUEUE_SCRIPT)
code = r.evalsha(
DEDUCT_ENQUEUE_SHA, 3,
stock_key, queue_key, bought_key,
1, order_id, user_id, product_id, int(time.time() * 1000),
)
return {1: 'QUEUED', 0: 'SOLD_OUT', -1: 'DUPLICATE', -2: 'NOT_STARTED'}[code]
Redis 集群注意:脚本涉及多个 key,这些 key 必须落在同一个 hash slot 上。队列名里用
{activityId}这种 hash tag,把同一场活动的 key 固定到一个槽,否则脚本会直接报CROSSSLOT。
第二步:消费者——先挪走,再处理,最后 ACK
消费者用 BRPOPLPUSH 把消息从队列原子地挪到”处理中”队列:
QUEUE_KEY = 'order:queue:{1001}'
PROCESSING_KEY = 'order:processing:{1001}'
while True:
raw = r.brpoplpush(QUEUE_KEY, PROCESSING_KEY, timeout=5)
if raw is None:
continue
msg = json.loads(raw)
try:
ok = create_order(msg)
except Exception:
schedule_retry(raw, msg) # 见「重试机制详解」
continue
if ok:
r.lrem(PROCESSING_KEY, 1, raw) # ACK:从处理中队列移除
else:
schedule_retry(raw, msg)
“处理中”队列是崩溃恢复的关键:消费者在处理过程中被 kill,消息已经不在主队列里,但它还在处理中队列里。重启后扫描这个队列,把残留消息重新投回主队列,一条都不会丢。
第三步:创建订单(幂等)
def create_order(msg: dict) -> bool:
"""幂等地创建订单并扣减 MySQL 库存。返回 False 表示业务上不可重试。"""
try:
with db.begin() as cur:
# 唯一索引 order_id 是幂等的最终保证
cur.execute(
"INSERT INTO orders (order_id, user_id, product_id, quantity, status, created_at) "
"VALUES (%s, %s, %s, %s, 'PENDING_PAY', NOW())",
(msg['order_id'], msg['user_id'], msg['product_id'], msg['quantity']),
)
# 兜底防线:库存不足直接失败,整个事务回滚
cur.execute(
"UPDATE product SET stock = stock - %s WHERE id = %s AND stock >= %s",
(msg['quantity'], msg['product_id'], msg['quantity']),
)
if cur.rowcount == 0:
raise StockNotEnough()
return True
except DuplicateOrder: # 唯一索引冲突 = 已经处理过
return True
except StockNotEnough: # 业务失败,重试也没用
return False
第四步:把结果告诉用户
用户拿到的是”处理中”,最终结果要靠查询或推送送达:
用户端轮询 GET /api/order/{orderId}:
status = PROCESSING → 继续等(间隔递增:1s → 2s → 4s)
status = SUCCESS → 支付页
status = FAILED → 失败原因 + 重试入口
服务端推送(可选):创建成功后写一条 outbox 记录,由推送服务消费
查询是必须的,推送是锦上添花。 推送可能失败(用户离线、网络不通、厂商通道抖动),如果只有推送没有查询,用户就永远不知道自己到底抢没抢到——这是最常见也最致命的一种体验事故。具体的通知方案是本页最后「想一想」的讨论对象。
第五步:失败怎么办
所有失败路径汇总成一张表:
| 失败点 | 现象 | 处理 | 谁负责 |
|---|---|---|---|
| 扣减时库存不足 | 脚本返回 0 | 直接返回”已售罄” | 生产者 |
| 扣减后、入队前崩溃 | 库存少 1,无订单 | 对账任务补回库存 | 离线对账 |
| 入队成功、消费者崩溃 | 消息在处理中队列 | 重启后扫描处理中队列重投 | 消费者 |
| MySQL 写入超时 | 事务未提交 | 重试(幂等保证安全) | 消费者 |
| 唯一索引冲突 | 订单已存在 | 视为成功,ACK | 消费者 |
| 条件更新失败 | MySQL 库存不足 | 业务失败,不重试 | 消费者 |
| 重试超过上限 | 反复失败 | 进死信队列 + 告警 | 消费者 |
队列把”处理失败”这件事从一次同步调用,变成了一次需要显式设计的后台重试。重试做得不好,比不重试更糟——它会把一个瞬时故障放大成一场雪崩。
先把失败分成两类
这是重试设计的第一步,也是最容易被跳过的一步。 所有失败都用同一套策略重试,等于把数据库打挂。
| 类型 | 典型原因 | 能不能重试 | 例子 |
|---|---|---|---|
| 瞬时故障 | 网络抖动、连接池耗尽、主从切换、锁等待超时 | ✅ 应该重试 | 数据库连接超时 |
| 业务失败 | 库存不足、参数非法、商品已下架 | ❌ 重试也没用 | stock >= 1 不满足 |
| 系统故障 | 代码 bug、数据格式错误、依赖服务持续不可用 | ⚠️ 有限次后放弃 | 字段解析失败 |
判断标准很简单:同样的输入再执行一次,结果会变吗? 会变(库存可能被补回来了、连接可能恢复了)→ 可以重试;不会变(数据非法、状态已经终态)→ 不要重试,立即失败。
退避策略:不能立刻重试
如果失败了立刻重试,10 个消费者会在同一毫秒集体扑向刚刚恢复的数据库,把它再次打挂——这叫重试风暴。
标准做法是指数退避加随机抖动:
第 n 次重试的等待时间 = base × 2^(n-1) + random(0, jitter)
base = 100ms, jitter = 50ms 时:
第 1 次:100ms + rand(0,50) → 100 ~ 150ms
第 2 次:200ms + rand(0,50) → 200 ~ 250ms
第 3 次:400ms + rand(0,50) → 400 ~ 450ms
第 4 次:800ms + rand(0,50) → 800 ~ 850ms
抖动不是可选项。没有抖动,所有消费者的退避时刻完全对齐,等于把重试变成了周期性的同步脉冲,照样能打挂下游。
重试的实现
用 Redis 的有序集合做”延迟队列”,按到期时间取消息:
RETRY_MAX = 5
RETRY_KEY = 'order:retry:{1001}'
DEAD_KEY = 'order:dead:{1001}'
BASE_DELAY = 0.1 # 100ms
MAX_DELAY = 30 # 最多退避 30 秒
JITTER = 0.05
def schedule_retry(raw: str, msg: dict, attempt: int = 1) -> None:
if attempt > RETRY_MAX:
# 超过上限:进死信队列 + 告警,不再自动重试
r.lpush(DEAD_KEY, raw)
r.hset(f'order:retry_count:{msg["order_id"]}', 'attempt', attempt)
alert('订单创建重试超限', order_id=msg['order_id'], attempt=attempt)
return
delay = min(BASE_DELAY * (2 ** (attempt - 1)), MAX_DELAY)
delay += random.uniform(0, JITTER)
due_at = time.time() + delay
# 重试次数随消息一起传递
msg['attempt'] = attempt
r.zadd(RETRY_KEY, {json.dumps(msg, ensure_ascii=False): due_at})
调度器负责把到期的消息挪回主队列:
def retry_scheduler(queue_key: str):
while True:
now = time.time()
due = r.zrangebyscore(RETRY_KEY, '-inf', now, start=0, num=100)
for raw in due:
if r.zrem(RETRY_KEY, raw): # 抢到才移除,避免重复投递
r.lpush(queue_key, raw)
time.sleep(0.5)
ZREM 的返回值要用上:多个调度器实例同时取到同一条消息时,只有 ZREM 返回 1 的那个实例负责投递,其他实例直接跳过。这是一个基于 Redis 的轻量”抢锁”。
死信队列
超过重试上限的消息不能直接丢弃,也不能无限重试:
死信队列(order:dead:{activityId})
↓
定时扫描 / 人工触发
↓
分类处理:
· 可自动修复(数据库短暂不可用已恢复)→ 手动重放
· 业务失败(库存不足)→ 释放 Redis 库存,回写失败结果
· 未知原因 → 告警 + 人工排查
死信队列必须有告警,而且告警要能定位到具体的订单号。 一条”有 3 条消息进了死信队列”的告警没有用,值班的人需要知道是哪三个订单、卡在哪一步、已经持续了多久。
重试的副作用:重复消费
重试机制本身会制造重复——同一条消息被处理多次是必然的,不是意外。所以下一节要解决的幂等,不是可选项,而是重试机制的必要配套。
幂等是什么
幂等 = 同一个请求执行一次和执行多次,对系统状态的影响完全相同。
在秒杀里,幂等不是”优化项”,而是”正确性前提”。原因很直接:上一节的重试机制保证了”最终会成功”,但代价是”同一条消息可能被处理多次”。如果不幂等,重试就从”修复故障”变成了”制造故障”。
重复从哪来
场景 1:消费者处理成功,但 ACK 前网络断了
→ 消息被重新投递 → 处理第 2 次
场景 2:消费者处理到一半崩溃
→ 消息重新投递 → 处理第 2 次
场景 3:重试机制把失败消息重新投递
→ 这是设计意图,不是意外
场景 4:两个消费者抢到同一条消息(ACK 状态判断出错)
→ 处理 2 次
场景 5:人工重放死信队列里的消息
→ 处理 2 次(这次往往是故意的)
共同点:消息系统的投递语义是”至少一次”(at-least-once),不是”恰好一次”(exactly-once)。 恰好一次在跨系统场景下代价极高,绝大多数生产系统都选择”至少一次 + 幂等”。
幂等键怎么选
幂等键必须满足两个条件:
- 同一个业务请求重试时,键不变——否则就识别不出是同一个请求。
- 不同业务请求的键绝不冲突——否则会误判成重复,丢掉真实订单。
秒杀场景里最自然的选择是订单号:它由服务端在请求入口生成(不是客户端传的),全局唯一,同一次抢购无论重试多少次都是同一个值。
| 候选幂等键 | 是否可用 | 原因 |
|---|---|---|
| 用户 ID | ❌ | 同一用户可能买多件、参加多次活动,要加活动维度 |
| 请求参数哈希 | ❌ | 参数相同的两笔合法订单会被误判重复 |
| 客户端生成的请求 ID | ⚠️ | 可信度低,脚本可以随意伪造 |
| 服务端生成的订单号 | ✅ | 入口生成、全局唯一、重试不变 |
三层幂等防护
第 1 层:Redis 快速去重(挡住绝大多数重复,纳秒级)
↓ 没挡住
第 2 层:业务查询(订单是否已存在)
↓ 没挡住
第 3 层:数据库唯一索引(最终保证,数据库层面不可能突破)
三层不是冗余,是成本递减的漏斗:
| 层 | 手段 | 开销 | 能挡住 |
|---|---|---|---|
| 1 | Redis SET key 1 NX EX ttl | 一次内存操作 | 99%+ 的重复(尤其是重试风暴) |
| 2 | SELECT 1 FROM orders WHERE order_id = ? | 一次索引查询 | 跨实例、跨时间窗的重复 |
| 3 | orders.order_id 唯一索引 | 零额外开销(约束自带) | 全部,包括前两层都失效的情况 |
第 3 层是唯一”独立成立”的防线,前两层都是性能优化。第 2 层和第 3 层看起来重复,但第 2 层能提前返回、避免无谓的异常和事务回滚;第 3 层则保证即使前两层被绕过,数据库也不会出现两条相同订单号的订单。
幂等不等于分布式锁
一个常见的错误做法:加一把分布式锁,保证同一时刻只有一个消费者在处理这条消息。
❌ 用锁保证"不并发",而不是保证"不重复"
锁只能挡住并发的重复消费,挡不住串行的重复消费——第一个消费者处理完释放锁后,第二个消费者照样会拿到同一条消息再处理一遍。而锁本身还要处理超时、续期、误释放,复杂度远高于幂等。幂等解决的是”结果”问题,锁解决的是”时序”问题,两者不能互相替代。
幂等性方案落地
订单表的约束
CREATE TABLE orders (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
order_id VARCHAR(32) NOT NULL COMMENT '服务端生成的全局唯一订单号,幂等键',
user_id BIGINT UNSIGNED NOT NULL,
product_id BIGINT UNSIGNED NOT NULL,
activity_id BIGINT UNSIGNED NOT NULL,
quantity INT NOT NULL DEFAULT 1,
status VARCHAR(16) NOT NULL DEFAULT 'PENDING_PAY',
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (id),
UNIQUE KEY uk_order_id (order_id),
KEY idx_user_activity (user_id, activity_id)
) ENGINE=InnoDB;
uk_order_id 就是幂等的物理保证。 没有它,“幂等”只是应用层的一个 if 判断——而应用层判断和数据库写入之间永远存在一个窗口:
检查「订单不存在」 ← 此刻还没有订单
↓
(此刻另一个消费者插入了同一条订单)
INSERT INTO orders ... ← 此刻插进去了
两个消费者同时通过检查,就会插入两条订单。唯一索引把这个窗口从”应用逻辑”下沉到了”数据库约束”,它不需要任何人配合就能生效。
幂等状态:处理中 / 已完成
单纯的”是否存在”判断还有一个问题:消费失败时的中间状态。用两个状态把语义补完整:
PROCESSING:本次处理正在进行,加了短 TTL
SUCCESS:处理成功,可以直接 ACK
def claim(order_id: str) -> bool:
"""抢占处理权。返回 False 表示别人正在处理,或已经处理过了。"""
key = f'order:idem:{order_id}'
if not r.set(key, 'PROCESSING', nx=True, ex=60):
# 抢不到:要么别人在处理(PROCESSING),要么已经成功(SUCCESS)
return False
return True
先占位、后处理、失败删标记这个顺序很重要:
def handle(raw: str, msg: dict) -> None:
order_id = msg['order_id']
if not claim(order_id):
r.lrem(PROCESSING_KEY, 1, raw) # 重复消息,直接 ACK
return
try:
create_order(msg) # 内部有唯一索引兜底
r.set(f'order:idem:{order_id}', 'SUCCESS', ex=86400)
r.lrem(PROCESSING_KEY, 1, raw)
except Exception:
r.delete(f'order:idem:{order_id}') # 失败要删标记,否则永远占着
schedule_retry(raw, msg)
失败时必须删除标记。 不删的话,这条订单会被永久标记为”处理中”,后面的重投全部被挡掉,订单就永远创建不出来——幂等键本身变成了丢单的原因。这是一个典型的”防御机制反噬”。
怎么验证幂等真的生效
不要靠推理,要靠压测:
def test_idempotency():
# 准备:1 件库存,1 个订单号
r.set('stock:1001', 1)
msg = {'order_id': 'A1001', 'user_id': 9527, 'product_id': 1001, 'quantity': 1}
# 模拟同一条消息被重复投递 100 次
for _ in range(100):
raw = json.dumps(msg)
r.lpush(PROCESSING_KEY, raw)
handle(raw, msg)
# 断言
assert db.query_one(
"SELECT COUNT(*) AS c FROM orders WHERE order_id = 'A1001'"
)['c'] == 1
assert db.query_one("SELECT stock FROM product WHERE id = 1001")['stock'] == 0
预期输出:
订单数量:1 ✅(不是 100)
MySQL 库存:0 ✅(不是 -99)
Redis 库存:0 ✅
三个数字必须同时检查。 只查订单数量,可能漏掉”订单只有一条但库存被扣了两次”的情况——那叫少卖不出单,用户拿到的是一个永远支付不了的空订单。
前面几节把消息的可靠性、幂等性都补上了。但还有一个问题没有回答:Redis 和 MySQL 什么时候能对上?
承认不一致窗口
异步架构下,Redis 和 MySQL 之间必然存在一个时间差:
T0 Redis 扣减成功(库存 100 → 99)
T1 消息入队
T2 消费者取出消息
T3 MySQL 事务提交(订单生成,MySQL 库存 100 → 99)
从 T0 到 T3 之间,两边就是不一致的。T3 - T0 就是一致性窗口。
这个窗口不可能做到为零。 强一致意味着扣减和落库必须在同一个事务里,那又回到了同步下单——数据库的吞吐天花板重新变成整个系统的天花板。我们接受这个窗口,代价是必须有一套机制保证它最终会收敛。
第 6.1 节专门讲了这个取舍:最终一致性不是偷懒,是性能约束下的最优解。这一页只讲异步下单这条链路上的具体保证。
三段式保证
不丢 ──────────────▶ 不重 ──────────────▶ 收敛
消息可靠投递 重复消费不产生副作用 差异最终被修复
(重试 + 持久化) (幂等键 + 唯一索引) (对账 + 补偿)
| 环节 | 保障手段 | 失效后果 |
|---|---|---|
| 不丢 | 队列持久化(AOF/RDB)、失败重试、处理中队列兜底、消费者异常恢复 | 用户有资格没订单,库存被永久占住 |
| 不重 | 幂等键、唯一索引、条件更新 | 重复扣库存、重复订单 |
| 收敛 | 定时对账(第 6.2 节)、差异修复 | 两边长期对不上 |
三段是串联的:第一段保证消息能到,第二段保证到了只生效一次,第三段保证即使前两段都失效,最终也能被发现和修正。少任何一段,系统都会留下一个”静默失败”的角落。
收敛的判据
对账任务要拿一个可以计算的等式来判断:
初始库存 = MySQL 已售 + MySQL 待支付占用 + Redis 剩余可售 + 异常差异
异步下单这条链路上,典型的异常差异有两种:
| 差异 | 成因 | 修复动作 |
|---|---|---|
| Redis 剩余偏多 | 扣减成功但订单最终没创建(进死信或消息丢失) | 补回 Redis 库存,订单标记失败 |
| MySQL 占用偏多 | Redis 扣减失败但订单已建(极少见的顺序错乱) | 人工介入,不自动修 |
超卖方向的差异绝不自动修复——它涉及已收款、可能已发货的订单,退款和召回必须人工决策。规则和第 6.2 节一致。
一致性窗口的量化
窗口不是抽象概念,它可以被打点监控:
每个订单记录两个时间戳:
deducted_at Redis 扣减成功的时间
committed_at MySQL 事务提交的时间
一致性窗口 = committed_at - deducted_at
监控指标:
| 指标 | 含义 | 建议阈值 |
|---|---|---|
| P99 一致性窗口 | 99% 的订单在多久内落库 | < 5 秒 |
| 最大窗口 | 最慢的订单等了多久 | < 60 秒 |
| 超阈值订单数 | 超过 60 秒还没落库的订单 | 0 |
| 对账差异量 | 每轮对账的差异件数 | 0 |
把一致性窗口做成一个可观测指标,比事后靠对账发现差异要主动得多。窗口突然拉长,往往意味着消费者变慢、队列积压或者数据库开始出现瓶颈——这是扩容和降级的早期信号。
一致性的边界
最后要说清楚一件事:这套机制保证的是”库存和订单最终对得上”,不是”用户一定能买到”。
用户 A 抢到了资格,订单创建失败(进死信)→ 用户 A 没买到,库存补回
用户 B 抢到了资格,订单创建成功 → 用户 B 买到
这是业务上的”少卖”,不是系统 bug。系统要做的是:把少卖的原因讲清楚(用户看到”未抢到,系统异常,请重试”),并且在对账时把库存补回去,让后面的人有机会买到。至于”要不要给用户 A 补偿”,是业务决策,不是技术问题。
数字对比
| 指标 | 同步下单 | 异步下单 | 变化 |
|---|---|---|---|
| 主链路同步写 | 2 次 MySQL 写 | 0 次 | 写库次数归零 |
| 主链路峰值吞吐 | 5,000-20,000 QPS | 100,000+ QPS | 提升 5-20 倍 |
| 用户 P99 延迟 | 300-800ms | 5-15ms | 下降 95%+ |
| 数据库峰值写 QPS | 与入口同量级 | 取决于消费者并发 | 降低 1-2 个数量级 |
| 单请求故障影响 | 当场失败,用户可见 | 转成后台重试 | 故障半径从”用户”变成”消息” |
| 结果一致性 | 强一致(当场确定) | 最终一致(秒级窗口) | 变弱 |
关键的是”主链路峰值吞吐”和”用户 P99 延迟”这两项。 吞吐决定了系统能扛多大的活动规模,延迟决定了用户点下按钮之后要等多久才看到反应——对秒杀来说,这两项直接决定了体验是”丝滑”还是”卡死”。
延迟拆解
同步路径:
Redis 扣减 0.5ms
MySQL 插订单 15ms ┐
MySQL 扣库存 15ms ├ 串行累加
事务提交 + 网络 5ms ┘
─────────────────────────
用户感知 ≈ 35ms(单机乐观锁)/ 数百 ms(高并发锁等待)
异步路径:
Redis Lua 扣减 + 入队 1ms
返回给用户 ≈ 1-2ms
(订单在后台落库,通常 50-500ms 后可查)
主链路的耗时从”两次数据库写”变成”一次内存操作”,这就是数量级的来源。
瓶颈转移了
这是必须诚实面对的一点:异步不是消灭瓶颈,是把瓶颈搬了个地方。
同步路径的瓶颈:MySQL 写入能力(5,000-20,000 QPS)
异步路径的瓶颈:队列容量 + 消费者并发度 + 消费速度
新的瓶颈有三个,都需要提前算:
| 新瓶颈 | 怎么算 | 算错了会怎样 |
|---|---|---|
| 队列内存 | 峰值请求数 × 单条消息大小 × 积压时间 | Redis 内存打满,队列不可用 |
| 消费速度 | 消费者并发数 × 单条处理耗时 | 队列持续积压,用户等太久 |
| 积压时长 | 积压消息数 ÷ 消费速度 | 用户几分钟后才拿到结果,失去秒杀意义 |
一个具体的算例:
活动:库存 100 件,预计 5 万人抢
进入主链路的有效请求:假设限流 + 风控后剩 1 万个
消费者:20 个,单条处理 10ms → 消费能力 2,000 QPS
积压:1 万 ÷ 2,000 = 5 秒消化完
结论:可接受,用户最多等 5 秒拿到结果
如果消费者只有 2 个,消化时间就是 50 秒——这时候排队系统(第 5 章)就得上场了,因为它可以把”瞬时涌入”变成”按放行速率进入”。
代价
成本 1:代码复杂度上升
同步下单是一个函数,异步下单是一套分布式事务的替代品
→ 重试、幂等、死信、对账,一样都不能少
成本 2:用户体验从"确定"变成"等待"
同步:抢购成功 / 失败
异步:处理中 → 稍后查看
→ 必须要有清晰的状态反馈和结果通知,否则用户会反复刷新
成本 3:故障排查变难
一个"订单没生成"的问题,要同时看 Redis、队列、消费者日志、MySQL
→ 必须有贯穿全链路的 order_id,以及可观测的队列与消费指标
这三项代价都是真实的,但它们换来的是数量级的吞吐提升。 在秒杀这个场景里,这笔交易是划算的——前提是你确实把这三块都补上了。少补任何一块,异步就会从”解决方案”变成”问题制造机”。
阶段小结
这一页的核心结论:
- 异步是性能约束下的必然选择,不是可以偷懒的替代方案——同步路径会把数据库写放在用户的等待链路上。
- 扣减与入队必须原子(同一个 Lua 脚本),否则会凭空丢单。
- 重试要分类、要退避、要加抖动,无限重试会把瞬时故障放大成雪崩。
- 重试必然带来重复,所以幂等是必需配套,不是可选项。
- 幂等要分层,但只有数据库唯一索引是独立成立的防线;幂等标记失败时必须删除,否则会变成丢单的原因。
- 最终一致性靠”不丢 + 不重 + 收敛”三段保证,对账是最后一段,也是唯一能兜住所有未知故障的一段。
- 瓶颈只是转移了不是消失了——队列内存、消费速度、积压时长都要提前算。
第 5 章开始处理另一个维度:如何在入口就把无效流量挡掉,让真正有效的请求以一个可控的速率进入这条链路。
问题 1:如何通知用户订单结果?
提示:
- 订单处理可能需要几秒
- 用户如何知道成功了还是失败了?
- 推送通知、短信、邮件?
解题思路
异步之后,“抢购结果”不再由接口返回,而是由系统稍后产生。所以要回答两个问题:结果从哪条通道到达用户,以及通道不可靠时怎么办。核心判断是:查询是主路径,推送是增强路径。
详细步骤
- 先定义订单状态机,没有状态机就没法查、也没法推:
PROCESSING 已受理,未落库
SUCCESS 订单创建成功,待支付
FAILED 创建失败(业务原因,如库存不足)
EXPIRED 长时间未完成,已被补偿关闭-
提供查询接口,这是必须项:
GET /api/order/{orderId},返回status和失败原因。前端按递增间隔轮询(1s → 2s → 4s → 8s,上限 30s),避免固定高频轮询在几十万用户下自己变成一次洪峰。 -
推送是增强项:App Push、小程序订阅消息、短信各有各的送达率,任何一条通道都可能失败。推送内容里要带订单号和跳转链接,让用户即使没收到推送也能自己查。
-
推送必须幂等:用
SETNX push:notified:{orderId}做去重,否则重试和重放会造成重复轰炸——用户收到三条”抢购成功”比收不到更糟。 -
要有兜底扫描:定时任务扫描长时间处于
PROCESSING的订单,要么补齐结果,要么置为EXPIRED并释放 Redis 库存。这条路径覆盖了”推送通道全挂”的情况。 -
文案要让用户可解释:区分”已收到请求,正在处理”、“抢购成功”、“手慢了,已售罄”、“系统繁忙,可重试”。第 1 章就说过,秒杀系统的目标之一是”可解释”。
最终答案
查询是必须的,推送是锦上添花:客户端轮询订单状态作为主路径,服务端推送作为加速路径,推送要做幂等去重,再加一条兜底扫描处理长时间挂起的订单。任何”只有推送没有查询”的方案都会在推送失败时让用户永远不知道结果。
问题 2:消费者崩溃导致消息丢失怎么办?
提示:
- 消费者从队列取出消息
- 处理过程中崩溃
- 消息既不在队列,也没有处理成功
解题思路
“消息丢了”其实是三个不同的问题,要分开看:消息从未入队、消息已入队但被弹出后崩溃、消息已处理但没 ACK。每个位置的解法不同,缺一层就有一类丢失。
详细步骤
-
从未入队:靠生产端的原子性。扣减与入队放在同一个 Lua 脚本里,脚本要么整体成功要么整体不执行,中途崩溃不会留下”扣了库存但没消息”的中间态。剩下的极端情况(脚本成功后进程立刻被 kill)由对账兜底。
-
已入队、被弹出、处理中崩溃:这是最常见的一类。解法是把”弹出”和”确认”拆开,用
BRPOPLPUSH先把消息原子地挪到”处理中”队列,处理成功后再从处理中队列里删掉。消费者重启时扫描处理中队列,把残留消息重新投回主队列。 -
已处理但没 ACK:同样由处理中队列兜住——消息还在处理中队列里,重启后会被重新处理。此时幂等就是必需的:它保证重复处理不会产生第二张订单、不会扣第二次库存。
-
队列本身的数据可靠性:开启 AOF(
appendonly yes,appendfsync everysec)并确保禁用淘汰(maxmemory-policy noeviction)。如果 Redis 开了allkeys-lru,内存压力下队列 key 会被直接淘汰掉——那才是真正意义上的”消息丢了”,而且是静默的。 -
处理失败:进入重试与死信机制,超过重试上限的消息进死信队列并告警。死信里的消息要能被重新放回主队列。
-
最后兜底:对账任务(第 6.2 节)扫描”Redis 已扣减但 MySQL 没有对应订单”的差额,补回库存并把订单标记为失败。
最终答案
靠五层机制叠加:生产端 Lua 原子扣减+入队、BRPOPLPUSH 处理中队列、ACK 放在业务提交之后、队列持久化且禁用淘汰、重试与死信队列;最后由对账兜住所有在线机制都失效的情况。核心判断是——只要消息还在队列里,它就没丢;真正危险的是它被消费掉了却没有留下任何痕迹。
问题 3:如何监控异步下单的健康状态?
提示:
- 队列长度监控
- 消费者处理速度监控
- 失败率监控
解题思路
把异步链路看成一个漏斗:入队速率 → 队列积压 → 出队速率 → 落库速率。健康度的核心是判断”积压是在消化还是在增长”,其余指标都是这个判断的辅助。
详细步骤
-
队列长度与积压趋势:同时监控”入队速率”和”出队速率”。只看长度会被误导——长度大但出队快是正常积压,长度不大但出队为 0 才是事故。真正的告警条件是:队列长度持续增长,且出队速率低于入队速率。
-
消息驻留时间(消费延迟 P99):给每条消息带上入队时间戳,出队时算差值。这个指标比队列长度更直接地反映”用户要等多久”,通常比长度更早发现问题。
-
失败率与重试率:消费失败率、重试次数分布、进死信队列的条数。失败率突然升高,往往是数据库或下游依赖出现了问题。
-
死信队列长度:这个指标应该是 0。任何非 0 都要告警,而且告警要带订单号——死信里的消息不会自己消失,每一条都是一张待处理的”用户没抢到”的订单。
-
一致性窗口 P99:从 Redis 扣减成功到 MySQL 提交的时间差(详见「最终一致性保证」)。窗口拉长是消费者变慢或队列积压的早期信号,比失败率更早出现。
-
幂等命中率:被幂等层拦下的重复消息占比。正常应该很低;突然升高说明消息在重复投递(ACK 异常或网络抖动),是潜在的雪崩前兆。
-
对账差异量:每轮对账的差异件数,目标是 0。这是所有其他指标失效后的最后一道信号。
-
看板与告警分级:把上面指标做成一张实时看板;告警分 P0(队列停止消费、死信增长)和 P1(延迟升高、失败率升高)两级,P0 直接通知值班。
最终答案
至少盯住五个核心指标:队列长度与积压趋势、消费延迟 P99、失败率与重试率、死信队列条数、一致性窗口 P99;再辅以幂等命中率和对账差异量。判断健康与否的关键不是”队列有多长”,而是积压是在被消化还是在持续增长——这是扩容、降级和熔断决策的直接依据。
发现内容有问题?
告诉我们哪里需要改进。
