异步下单:异步处理订单提升吞吐量

问题:订单创建失败怎么办?😰

前两节我们建立了完整的流程:

用户请求 → 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业务事实来源订单号唯一索引 + 条件更新,两道防线独立成立
结果通知把异步结果告诉用户必须有查询兜底,不能只依赖推送

这张图里有三个”必须”,每一个都是后面小节的主题:

  1. 扣减和入队必须原子。 如果拆成两步——先扣库存再入队——中间崩溃就会凭空少一个订单。这正是 4.1 节 Lua 脚本的思路,这里把队列 key 也放进脚本。
  2. 消费必须幂等。 队列的语义是”至少一次投递”,重复是常态而不是意外。
  3. 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)。 恰好一次在跨系统场景下代价极高,绝大多数生产系统都选择”至少一次 + 幂等”。

幂等键怎么选

幂等键必须满足两个条件:

  1. 同一个业务请求重试时,键不变——否则就识别不出是同一个请求。
  2. 不同业务请求的键绝不冲突——否则会误判成重复,丢掉真实订单。

秒杀场景里最自然的选择是订单号:它由服务端在请求入口生成(不是客户端传的),全局唯一,同一次抢购无论重试多少次都是同一个值。

候选幂等键是否可用原因
用户 ID❌同一用户可能买多件、参加多次活动,要加活动维度
请求参数哈希❌参数相同的两笔合法订单会被误判重复
客户端生成的请求 ID⚠️可信度低,脚本可以随意伪造
服务端生成的订单号✅入口生成、全局唯一、重试不变

三层幂等防护

第 1 层:Redis 快速去重(挡住绝大多数重复,纳秒级)
   ↓ 没挡住
第 2 层:业务查询(订单是否已存在)
   ↓ 没挡住
第 3 层:数据库唯一索引(最终保证,数据库层面不可能突破)

三层不是冗余,是成本递减的漏斗:

层手段开销能挡住
1Redis SET key 1 NX EX ttl一次内存操作99%+ 的重复(尤其是重试风暴)
2SELECT 1 FROM orders WHERE order_id = ?一次索引查询跨实例、跨时间窗的重复
3orders.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 QPS100,000+ QPS提升 5-20 倍
用户 P99 延迟300-800ms5-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,以及可观测的队列与消费指标

这三项代价都是真实的,但它们换来的是数量级的吞吐提升。 在秒杀这个场景里,这笔交易是划算的——前提是你确实把这三块都补上了。少补任何一块,异步就会从”解决方案”变成”问题制造机”。

阶段小结

这一页的核心结论:

  1. 异步是性能约束下的必然选择,不是可以偷懒的替代方案——同步路径会把数据库写放在用户的等待链路上。
  2. 扣减与入队必须原子(同一个 Lua 脚本),否则会凭空丢单。
  3. 重试要分类、要退避、要加抖动,无限重试会把瞬时故障放大成雪崩。
  4. 重试必然带来重复,所以幂等是必需配套,不是可选项。
  5. 幂等要分层,但只有数据库唯一索引是独立成立的防线;幂等标记失败时必须删除,否则会变成丢单的原因。
  6. 最终一致性靠”不丢 + 不重 + 收敛”三段保证,对账是最后一段,也是唯一能兜住所有未知故障的一段。
  7. 瓶颈只是转移了不是消失了——队列内存、消费速度、积压时长都要提前算。

第 5 章开始处理另一个维度:如何在入口就把无效流量挡掉,让真正有效的请求以一个可控的速率进入这条链路。


想一想

问题 1:如何通知用户订单结果?

提示:

  • 订单处理可能需要几秒
  • 用户如何知道成功了还是失败了?
  • 推送通知、短信、邮件?
异步下单结果通知用户体验

解题思路

异步之后,“抢购结果”不再由接口返回,而是由系统稍后产生。所以要回答两个问题:结果从哪条通道到达用户,以及通道不可靠时怎么办。核心判断是:查询是主路径,推送是增强路径。

详细步骤

  1. 先定义订单状态机,没有状态机就没法查、也没法推:
PROCESSING   已受理,未落库
SUCCESS      订单创建成功,待支付
FAILED       创建失败(业务原因,如库存不足)
EXPIRED      长时间未完成,已被补偿关闭
  1. 提供查询接口,这是必须项:GET /api/order/{orderId},返回 status 和失败原因。前端按递增间隔轮询(1s → 2s → 4s → 8s,上限 30s),避免固定高频轮询在几十万用户下自己变成一次洪峰。

  2. 推送是增强项:App Push、小程序订阅消息、短信各有各的送达率,任何一条通道都可能失败。推送内容里要带订单号和跳转链接,让用户即使没收到推送也能自己查。

  3. 推送必须幂等:用 SETNX push:notified:{orderId} 做去重,否则重试和重放会造成重复轰炸——用户收到三条”抢购成功”比收不到更糟。

  4. 要有兜底扫描:定时任务扫描长时间处于 PROCESSING 的订单,要么补齐结果,要么置为 EXPIRED 并释放 Redis 库存。这条路径覆盖了”推送通道全挂”的情况。

  5. 文案要让用户可解释:区分”已收到请求,正在处理”、“抢购成功”、“手慢了,已售罄”、“系统繁忙,可重试”。第 1 章就说过,秒杀系统的目标之一是”可解释”。

最终答案

查询是必须的,推送是锦上添花:客户端轮询订单状态作为主路径,服务端推送作为加速路径,推送要做幂等去重,再加一条兜底扫描处理长时间挂起的订单。任何”只有推送没有查询”的方案都会在推送失败时让用户永远不知道结果。

问题 2:消费者崩溃导致消息丢失怎么办?

提示:

  • 消费者从队列取出消息
  • 处理过程中崩溃
  • 消息既不在队列,也没有处理成功
消息可靠性死信队列崩溃恢复

解题思路

“消息丢了”其实是三个不同的问题,要分开看:消息从未入队、消息已入队但被弹出后崩溃、消息已处理但没 ACK。每个位置的解法不同,缺一层就有一类丢失。

详细步骤

  1. 从未入队:靠生产端的原子性。扣减与入队放在同一个 Lua 脚本里,脚本要么整体成功要么整体不执行,中途崩溃不会留下”扣了库存但没消息”的中间态。剩下的极端情况(脚本成功后进程立刻被 kill)由对账兜底。

  2. 已入队、被弹出、处理中崩溃:这是最常见的一类。解法是把”弹出”和”确认”拆开,用 BRPOPLPUSH 先把消息原子地挪到”处理中”队列,处理成功后再从处理中队列里删掉。消费者重启时扫描处理中队列,把残留消息重新投回主队列。

  3. 已处理但没 ACK:同样由处理中队列兜住——消息还在处理中队列里,重启后会被重新处理。此时幂等就是必需的:它保证重复处理不会产生第二张订单、不会扣第二次库存。

  4. 队列本身的数据可靠性:开启 AOF(appendonly yes,appendfsync everysec)并确保禁用淘汰(maxmemory-policy noeviction)。如果 Redis 开了 allkeys-lru,内存压力下队列 key 会被直接淘汰掉——那才是真正意义上的”消息丢了”,而且是静默的。

  5. 处理失败:进入重试与死信机制,超过重试上限的消息进死信队列并告警。死信里的消息要能被重新放回主队列。

  6. 最后兜底:对账任务(第 6.2 节)扫描”Redis 已扣减但 MySQL 没有对应订单”的差额,补回库存并把订单标记为失败。

最终答案

靠五层机制叠加:生产端 Lua 原子扣减+入队、BRPOPLPUSH 处理中队列、ACK 放在业务提交之后、队列持久化且禁用淘汰、重试与死信队列;最后由对账兜住所有在线机制都失效的情况。核心判断是——只要消息还在队列里,它就没丢;真正危险的是它被消费掉了却没有留下任何痕迹。

问题 3:如何监控异步下单的健康状态?

提示:

  • 队列长度监控
  • 消费者处理速度监控
  • 失败率监控
可观测性队列监控告警设计

解题思路

把异步链路看成一个漏斗:入队速率 → 队列积压 → 出队速率 → 落库速率。健康度的核心是判断”积压是在消化还是在增长”,其余指标都是这个判断的辅助。

详细步骤

  1. 队列长度与积压趋势:同时监控”入队速率”和”出队速率”。只看长度会被误导——长度大但出队快是正常积压,长度不大但出队为 0 才是事故。真正的告警条件是:队列长度持续增长,且出队速率低于入队速率。

  2. 消息驻留时间(消费延迟 P99):给每条消息带上入队时间戳,出队时算差值。这个指标比队列长度更直接地反映”用户要等多久”,通常比长度更早发现问题。

  3. 失败率与重试率:消费失败率、重试次数分布、进死信队列的条数。失败率突然升高,往往是数据库或下游依赖出现了问题。

  4. 死信队列长度:这个指标应该是 0。任何非 0 都要告警,而且告警要带订单号——死信里的消息不会自己消失,每一条都是一张待处理的”用户没抢到”的订单。

  5. 一致性窗口 P99:从 Redis 扣减成功到 MySQL 提交的时间差(详见「最终一致性保证」)。窗口拉长是消费者变慢或队列积压的早期信号,比失败率更早出现。

  6. 幂等命中率:被幂等层拦下的重复消息占比。正常应该很低;突然升高说明消息在重复投递(ACK 异常或网络抖动),是潜在的雪崩前兆。

  7. 对账差异量:每轮对账的差异件数,目标是 0。这是所有其他指标失效后的最后一道信号。

  8. 看板与告警分级:把上面指标做成一张实时看板;告警分 P0(队列停止消费、死信增长)和 P1(延迟升高、失败率升高)两级,P0 直接通知值班。

最终答案

至少盯住五个核心指标:队列长度与积压趋势、消费延迟 P99、失败率与重试率、死信队列条数、一致性窗口 P99;再辅以幂等命中率和对账差异量。判断健康与否的关键不是”队列有多长”,而是积压是在被消化还是在持续增长——这是扩容、降级和熔断决策的直接依据。

发现内容有问题?

告诉我们哪里需要改进。