最终一致:Redis与数据库的最终一致性

问题:Redis和MySQL数据不一样怎么办?😰

上一章我们把库存预扣搬到了 Redis,数据库只处理已经抢到资格的请求。链路跑通了,但新的问题冒出来:

用户请求 → Redis 扣库存 ✅ → 入队 ✅ → 消费者创建订单 ✅ → 扣 MySQL 库存 ❌

任何一环失败,Redis 和 MySQL 就会对不上。

具体会出哪些错:

场景 A:消费者处理订单时崩溃
  Redis 库存:99(已扣)
  MySQL 库存:100(没扣)
  结果:少卖 1 件,库存凭空消失

场景 B:扣 MySQL 库存时数据库报错
  Redis 库存:99(已扣)
  MySQL 库存:100(没扣)
  结果:同上,订单和库存都缺

场景 C:Redis 扣减成功,但入队失败
  Redis 库存:99(已扣)
  MySQL 库存:100(没扣)
  用户没抢到,库存却被占住

三个场景的共同点是:Redis 已经扣了,MySQL 还没跟上。

我们不可能让 Redis 和 MySQL 在同一时刻保持一致——那需要分布式事务,代价是性能直接回不到秒杀需要的水平。所以我们接受一个更现实的目标:允许短暂不一致,但保证最终能对上。

最终一致性理论 📚

最终一致性的意思很直白:系统不保证任意时刻两份数据都相同,但保证在没有新写入的情况下,经过一段时间两份数据会收敛到相同。

这里的关键是”没有新写入”。秒杀活动的高峰期一直在有新订单进来,一致性窗口是持续存在的;只有在活动结束、写入停止之后,才能真正确认两边对上了。所以最终一致性要配合对账才能落地——这正是下一页要解决的问题。

为什么会不一致

因为 Redis 和 MySQL 是两次独立写入,中间还夹着消息队列:

Redis 扣减  →  消息入队  →  消费者处理  →  MySQL 扣减
    T0            T1              T2                T3

任何一步失败或超时,两边的进度就会错开。这不是实现缺陷,而是异步架构的固有代价——用可控的不一致,换取数量级的性能提升。

哪些方案不可行

方案为什么不可行
强一致(分布式事务)跨服务两阶段提交,锁持有时间长,QPS 掉到几千,秒杀直接崩
全局锁串行所有写入所有请求排队,吞吐等于单服务,等于放弃秒杀
不做异步,直接写 MySQL回到第 3 章的数据库瓶颈,差 25-500 倍

所以最终一致性不是”我们懒得做对”,而是”在性能约束下的最优解”。

异步同步方案 🔄

我们需要在 Redis 扣减成功后,把这个变更可靠地同步到 MySQL。三条常见路径:

方案一:消息队列异步同步(推荐)⭐

Redis 扣减成功
      ↓
 发送消息到队列(stock:deduct:{orderId})
      ↓
 消费者收到消息 → 扣减 MySQL 库存 → 标记消息已处理

为什么用队列而不是直接写 MySQL:消息队列把”同步”这件事从主链路上摘了下来。Redis 扣减完就能立即返回用户成功,不需要等 MySQL,主链路的延迟被压到最低。

关键点在于幂等:消费者可能因为网络抖动、重启而重复消费同一条消息。如果每次消费都扣一次 MySQL 库存,就会把库存扣穿。所以扣减必须带上订单号,并且能识别”这条消息我已经处理过了”。

方案二:Binlog 订阅

MySQL 的 binlog 记录了所有数据变更,订阅它就能拿到”谁把库存改成什么值”的事实。

MySQL 主库 binlog → Canal/DataX → 消费端 → 更新 Redis

它的定位和队列方案相反:队列是”Redis 主动通知 MySQL 改”,binlog 订阅是”MySQL 改完了,通知 Redis 对齐”。适合 Redis 全量重建、缓存回填这类场景,但对实时性要求高的秒杀主链路来说,延迟比队列方案多一跳。

方案三:定时任务全量比对

定时把两边的库存捞出来逐个比对,差异的部分修正。

优点是简单、绝对不会漏;缺点是延迟高(取决于扫描周期)、数据量大时开销高。它不适合作为主同步机制,但作为兜底手段非常有价值。

三种方案对比

维度消息队列Binlog 订阅定时比对
延迟低(毫秒级)中高(分钟级)
可靠性依赖消息持久化依赖 binlog 完整最可靠,不漏
实现复杂度中高(需部署中间件)低
典型定位主同步机制缓存回填、灾备重建兜底校验

实际系统通常组合使用:队列做主链路,binlog 做恢复,比对做兜底。

该走哪条路

判断依据是谁是事实来源。

在秒杀场景里,MySQL 存着订单和真实成交记录,它是业务事实的最终来源;Redis 里的库存是可被重建的加速副本。所以:

  • 实时同步(Redis → MySQL)用队列,因为业务上要以 MySQL 的成交记录为准。
  • 缓存重建(MySQL → Redis)用 binlog 或定时任务。

搞反方向,是很多一致性事故的根源。

方案落地

把方案一完整走一遍。

第一步:扣减成功后写消息

Redis 扣减成功(返回剩余库存)
      ↓
发送消息:{ orderId, productId, quantity, timestamp }
      ↓
返回用户:抢购成功

这一步的关键是扣减成功才发消息。如果扣减失败(库存不足),根本不该有消息产生。

第二步:消费者幂等处理

消费者收到消息后要回答两个问题:这条消息我处理过吗?处理成功了怎么标记?

收到消息 { orderId: A1001, quantity: 1 }
      ↓
查订单表:order_id = A1001 是否已存在?
      ├─ 存在 → 已处理过,直接 ACK,跳过(幂等)
      └─ 不存在 → 继续
      ↓
开启事务:
  UPDATE product SET stock = stock - 1 WHERE id = ? AND stock >= 1
  INSERT INTO orders (order_id, product_id, quantity, status) VALUES (...)
  COMMIT
      ↓
ACK 消息

这里用”订单号唯一索引”做幂等键,比额外维护一张消费记录表更省事——订单表本身既是业务数据,也是消费凭证。

stock >= 1 这个条件不能省。即使 Redis 侧保证了不超卖,MySQL 侧也必须自己再挡一次。两道防线都要有,任意一道失效系统仍然安全。

第三步:失败处理

事务失败时不能 ACK 消息,要让它重回队列:

消费失败
  ↓
不 ACK → 消息重回队列
  ↓
重试(注意:重试间隔要退避,否则会打死数据库)
  ↓
超过重试次数 → 进死信队列 + 告警

死信队列必须有,否则一条永远处理不了的消息会把整个队列堵死。

“重试次数用完”和”消息处理成功”是两回事。超过次数不代表没问题,只是代表需要人工介入。死信队列里的消息必须有人看、有告警,否则一致性永远修不回来。

第四步:补偿兜底

上面所有机制都建立在”消息不丢”这个假设上。但进程可能被 kill、网络可能断、机器可能宕机。真正的兜底是对账——定期比对两边库存,发现差异就修复。这是下一页的内容。

阶段小结

这一页的核心结论:

  1. 最终一致性是主动选择,不是偷懒。强一致在秒杀的性能约束下不可行。
  2. 一致性窗口是异步架构的固有代价,关键是把窗口内的偏差收敛回来。
  3. 同步方向由事实来源决定:MySQL 是事实来源,所以实时同步走 Redis → MySQL,缓存重建走 MySQL → Redis。
  4. 幂等是消费端的第一要务。用订单号做幂等键,靠唯一索引而不是额外状态表。
  5. 每一道防线都要独立成立。Redis 挡一次,MySQL 的 stock >= 1 再挡一次,任何一道失效都不影响正确性。
  6. 失败路径比成功路径更需要设计:重试要退避,死信要告警,兜底要对账。

下一页要解决的就是第 6 条里最后一个缺口——当所有在线手段都没能保证一致时,怎么通过对账把数据修复回来。

想一想

问题 1:为什么不能反过来,让 MySQL 的 binlog 驱动 Redis 扣减?

最终一致性Binlog 订阅秒杀架构

解题思路:

这题的陷阱在于”binlog 订阅”听起来像一个现成的同步方案,但方向可能反了。要先确定谁是事实来源——订单和成交记录在 MySQL,扣减动作就必须以成交结果为准;再把反过来的链路完整推演一遍,看它会在哪一步失效、用户会看到什么;最后给出 binlog 订阅的正确用途。

详细步骤:

不能反过来的核心:MySQL 是业务事实来源,Redis 只是可重建的加速副本。

如果用 binlog 驱动 Redis 扣减,方向就反了——Redis 变成了扣减的发起方,MySQL 变成了被通知方。但订单和成交记录在 MySQL 里,扣减动作必须以 MySQL 的成交结果为准。让一个可以被重建的缓存去驱动事实来源,等于让缓存决定真相。

具体会出什么问题:

用户请求 → MySQL 扣库存(成了事实)→ binlog 通知 Redis 扣减

如果 Redis 扣减失败(Redis 宕机、网络不通、key 不存在),MySQL 里的库存已经扣了,订单已经创建,用户也收到了成功提示——但 Redis 里的库存还是 100。用户刷新页面看到”还有货”,下一次请求就会失败。

在这个方案里,“Redis 扣减成功”成了下单的前置条件,但 Redis 恰恰是整个系统里最不可靠的一环。

另一个问题是用户体验:秒杀的判断必须同步完成。binlog 订阅链路是 MySQL 写入 → binlog dump → 订阅端消费 → 更新 Redis,延迟在几十到几百毫秒。用户点了”抢购”要等这个链路走完才知道有没有抢到,这个延迟本身就不可接受。

binlog 订阅的 正确定位:它是 MySQL → Redis 的单向同步,用于缓存回填、Redis 故障后重建、或做数据校验,而不是用于主链路的库存扣减。

最终答案:

MySQL 是事实来源,实时同步必须走 Redis → MySQL(消息队列);binlog 订阅用于 MySQL → Redis 的缓存重建方向,不能反客为主。

问题 2:消费端幂等是用订单号唯一索引,还是维护一张消费记录表更好?

幂等设计消息队列数据库约束

解题思路:

这题要比较两种幂等实现,判据只有一个:幂等标记和业务写入能不能放进同一个事务。唯一索引方案把幂等键和业务数据放在同一处,幂等因此是”免费”的;消费记录表方案则多出一个跨事务的环节,要分析它在第几步失败会导致永久少扣。

详细步骤:

两种方案的对比:

维度订单号唯一索引消费记录表
额外写入无每次消费多一次 INSERT
一致性风险低(同一事务内)高(两张表要同事务)
存储成本无持续增长,需清理
排查直观性看订单表即可要关联两张表

推荐用订单号唯一索引。

理由是它把幂等键和业务数据放在同一处,用数据库的唯一约束来保证,而不是额外维护一张”已消费”表。这带来一个重要好处:幂等和业务写入在同一个事务里。

BEGIN
  INSERT INTO orders (order_id, ...) VALUES (...)   -- 唯一索引,重复则报错
  UPDATE product SET stock = stock - 1 WHERE id = ? AND stock >= 1
COMMIT

重复消费时,INSERT 会因为唯一索引冲突而失败,整个事务回滚——库存不会被扣第二次。幂等是”免费”的,不需要额外的判断逻辑。

消费记录表方案的问题在于它引入了两阶段:

1. INSERT INTO consumed_log (msg_id)   -- 标记已消费
2. UPDATE product SET stock = ...       -- 扣库存

如果第 1 步成功、第 2 步失败,消息被标记为已消费但库存没扣——下次重投时因为”已消费”而被跳过,库存就永久少扣了。必须把两步放进同一事务才能避免,而这又要求消费记录表和业务表在同一个数据库实例(跨库就做不到了)。

关于”扣减成功但插入订单失败”:

用唯一索引方案时,如果 UPDATE 成功但 INSERT 失败,事务回滚,库存自动还原——这是安全的。但如果代码里把 UPDATE 放在 INSERT 之前且没有事务包裹,就会扣了库存却没订单。所以关键是加事务,不只是加唯一索引。

最终答案:

用订单号唯一索引,并确保扣减与插单在同一事务内;消费记录表只有在跨库场景或需要记录额外消费上下文时才有必要。

问题 3:消息队列本身挂了,Redis 已经扣的库存怎么补回来?

消息队列库存补偿最终一致性对账

解题思路:

先要把”消息根本没发出去”和”发出去了但没被消费”分成两种情况,两者的补法完全不同。然后要问一个更关键的问题:这些补法依赖队列吗?如果队列挂了,所有依赖队列的补偿逻辑(重试、死信、告警)会一起失效,所以答案必须是一个绕开队列的独立机制。

详细步骤:

先分清是”消息没发出去”还是”消息发出去了没消费”,两者的补法不同。

情况 A:扣减成功,但发消息时进程崩溃,消息从未入队

Redis 扣减 ✅  →  发消息 ❌(进程崩溃)
结果:Redis 库存少 1,MySQL 库存没变,没有任何订单

这时候没有订单,MySQL 侧完全没动。补回方式:

补偿任务扫描:Redis 已扣减总量 > MySQL 占用 + MySQL 已售 + 正常预留
多出来的部分 → 补回 Redis 库存

因为没有订单对应,不涉及订单状态,只要按总量差额补回即可。这也是第 6.2 节对账机制处理的典型场景。

情况 B:消息已入队,但队列不可用导致消息堆积或丢失

Redis 扣减 ✅ →  入队 ✅  →  队列挂了 ❌

消息如果还在磁盘上(持久化队列),队列恢复后会被继续消费,属于”可恢复”,不需要额外补偿。如果消息确实丢了(队列没有持久化,或被清理),同样回到对账补偿。

关键结论:这类问题在线机制救不了,只能靠对账。

原因是队列挂掉时,任何依赖队列的补偿逻辑(重试、死信、告警)也都失效了。唯一还活着的是独立的、定时的、绕开队列的扫描任务——它直接查 Redis 和 MySQL 的状态做比对。

这也正是把对账做成独立机制的原因:它不能依赖同步链路的任何一环。队列是易失组件,对账任务必须是”哪怕主链路全挂了也能跑”的那条最后防线。

实践中的补充措施:

  • 扣减与发消息尽量放在同一个可靠流程里(用事务消息或本地消息表),减少”扣了但没发”的窗口。
  • 给 Redis 侧维护一个”已预扣总量”计数器,补偿时不依赖逐单比对。
  • 队列不可用时主动降级为直接落库,而不是让消息丢失。

最终答案:

靠独立的对账补偿任务扫描并补回;扣减与发消息之间用本地消息表或事务消息缩小窗口;队列不可用时降级为直接写库,不能静默丢消息。

发现内容有问题?

告诉我们哪里需要改进。