Skip to content

4.2-10 与 MySQL 的双写一致性 ​

所属:04 数据存储 / 4.2 Redis 分级:A 状态:◐ 初稿 关联:4.1-2、4.1-11、4.1-13、4.1-14、4.2-4、4.2-6、4.2-8、4.2-9

  • 题型:场景 / 设计 / 排障

  • 一句话结论:Redis 与 MySQL 的双写一致性,默认目标不是“强一致”,而是 以 MySQL 为唯一事实源、缓存最终一致:读走 Cache-Aside,写先提交 MySQL 再删除缓存,失败重试 + TTL 兜底;并发读回填旧值用延迟双删/版本号/分布式锁处理,跨服务用 binlog/Canal 或事务消息做可靠失效。强一致要靠锁/版本/读主,代价是性能和复杂度。

  • 分层要点:

    1. 先定一致性目标:MySQL 是事实源,Redis 是加速层。绝大多数业务接受“短暂旧值 + 最终一致”,用 TTL 兜底;金融/库存等强一致场景,要么读主/加锁/版本,要么不要让缓存参与关键判断。不要用“双写”假装原子,MySQL 和 Redis 没有跨库事务。
    2. 读路径 Cache-Aside:先读缓存,命中返回;未命中读 MySQL,再回填缓存。要防穿透(空值/布隆过滤器)、击穿(互斥/singleflight/逻辑过期)、雪崩(TTL 抖动),这些是 4.2-8 的问题,不要和双写一致性混为一谈。
    3. 写路径:先 DB 后删缓存:先提交 MySQL 事务,成功后再删除 Redis key;删除失败要重试/走补偿,不能吞掉。不要在事务提交前删缓存,也不要在事务里更新缓存:回滚会留下脏缓存,提交前删缓存会让并发读把旧值回填。
    4. 为什么删缓存而不是更新缓存:更新缓存会引入“两次更新到达顺序颠倒”的问题:T1 写 v1、T2 写 v2,但 T2 先更新缓存、T1 后更新,缓存停在 v1。删除是幂等的,下一次读会重新加载最新值;代价是一次 cache miss。
    5. 经典并发漏洞:先更新 DB 再删缓存,仍可能被“读未命中 → 读旧 DB → 写旧缓存”插队;先删缓存再更新 DB,也可能被“读未命中 → 回填旧值”插队。延迟双删是在更新后延迟再删一次,覆盖并发回填;但它不是强一致,睡眠时间要覆盖一次 DB 读 + 缓存写。
    6. 可靠失效:应用内删除失败不可靠,工程上用 binlog + Canal/Debezium + MQ 或 本地消息表/事务消息 驱动缓存删除;消息至少一次、消费幂等、失败重试 + 死信 + TTL。这样业务代码只写 DB,缓存失效由 CDC 异步完成,解耦且可补偿。
    7. 强一致手段:按 key 分布式锁把“读回填/写 DB/删缓存”串行化;或用版本号(DB version + key:v{version})让旧缓存自然失效;或写后读主(避免从库延迟回填旧值)。锁有超时/单点/Redlock 争议,版本号有存储/读版本成本,读主有主库压力。
    8. 多级缓存与热点:本地缓存 + Redis 时,失效要同时通知两层;pub/sub 不可靠,重要数据用 MQ 广播 + 短 TTL + 版本号。热 key 的本地缓存一致性、大 key 的删除阻塞(UNLINK)分别见 4.2-9,双写方案要把它们一起考虑。
  • 图/流程:

text
Cache-Aside 读:
  读请求 → Redis
    ├─ 命中 → 返回
    └─ 未命中 → MySQL
          ├─ 查到 → 回填 Redis(TTL)→ 返回
          └─ 未查到 → 空值缓存/布隆 → 返回
text
Cache-Aside 写:
  写请求 → MySQL 事务提交
    → 删除 Redis key
      ├─ 成功 → 返回
      └─ 失败 → 重试 / MQ 补偿 / TTL 兜底
text
并发读回填旧值(先更新 DB 再删缓存):
  T1: UPDATE DB v2(未提交/刚提交)
  T2: 读缓存 miss
  T2: 读 DB 得到 v1
  T1: 删除缓存
  T2: 把 v1 写回缓存   ← 脏数据
  解决:延迟再删一次 / 版本号 / 锁
text
先删缓存再更新 DB:
  T1: 删除缓存
  T2: 读 miss,读 DB v1,回填 v1
  T1: UPDATE DB v2
  → 缓存仍是 v1
  解决:更新后延迟再删 / 版本号
text
可靠失效(binlog + MQ):
  App → MySQL 提交 → binlog
    → Canal/Debezium → MQ(按 key 分区)
    → 消费者删除 Redis
      ├─ 成功 → ACK
      └─ 失败 → 重试 / 死信 / TTL
text
本地消息表/事务消息:
  DB 事务:业务表 + outbox 同事务提交
    → relay 投递 MQ
    → 消费者删缓存
  至少一次 + 幂等删除
text
版本号:
  DB: item(id, version, ...)
  Cache: item:{id}:v{version}
  写:DB version+1 → 新 key
  旧 key 靠 TTL 淘汰
  读:先取当前 version → 读对应 key
  • 版本/源码锚点:

    • MySQL 5.6+/8.0:binlog_format=ROW、GTID、半同步、组复制;Canal 依赖 ROW binlog。
    • Redis 4.0+:UNLINK、lazyfree;6.0+:ACL/TLS、多线程 IO;7.0:sharded pub/sub、CLIENT NO-EVICT 等。
    • 工程组件:Canal/Debezium、RocketMQ 事务消息、Kafka、本地消息表、Redisson/Redlock、Spring TransactionSynchronization.afterCommit。
    • 关键配置:MySQL binlog_format=ROW、binlog_row_image=FULL(CDC 更稳)、sync_binlog=1、innodb_flush_log_at_trx_commit=1;Redis maxmemory-policy、TTL、UNLINK。
    • 源码/实现:MySQL sql/binlog.cc、sql/rpl_binlog_sender.cc;Redis src/db.c(删除/过期)、src/t_string.c;Canal parse/sink/adapter。
  • 缓存模式对比:

模式读写一致性适用
Cache-Aside缓存 miss 读 DB 回填写 DB 后删缓存最终一致最常用
Read-Through缓存层加载 DB缓存层写取决于实现缓存框架
Write-Through缓存命中缓存同步写 DB较强写少、缓存层可靠
Write-Behind缓存命中缓存异步写 DB弱,可能丢写多、可容忍
  • 写顺序对比:
顺序问题结论
先删缓存 → 写 DB并发读回填旧值不推荐单独用
先写 DB → 删缓存并发读可能回填旧值基线方案,配合延迟双删/TTL
先写 DB → 更新缓存两次更新可能乱序不推荐,除非版本/CAS
事务内写 DB + 缓存回滚/提交前并发不推荐,缓存应在 afterCommit
  • 一致性方案对比:
方案一致性性能复杂度适用
先 DB 后删缓存 + TTL最终高低大多数业务
延迟双删最终(更稳)中中读并发高
binlog/Canal + MQ最终高高多服务、解耦
本地消息表/事务消息最终中高不允许丢失效消息
分布式锁较强低中关键 key、低并发
版本号较强高中可改 key 设计
写后读主/GTID wait读己之写中中主从延迟场景
  • 故障与兜底:
故障后果兜底
删缓存失败旧值残留重试、MQ、TTL、对账
消息丢失缓存不失效outbox/事务消息、重试、TTL
消费重复多次删除删除幂等
消费乱序旧值回填按 key 分区、版本号、TTL
读从库延迟回填旧值写后读主、GTID wait、短 TTL
缓存宕机请求打 DB限流、降级、熔断
大 key 删除阻塞UNLINK、分批、lazyfree
本地缓存多实例不一致MQ 广播、短 TTL、版本
  • 监控指标:
指标作用告警
缓存命中率效果持续下降
DB QPS/RT回源压力突增
删除失败/重试一致性风险增长
MQ 堆积/延迟失效延迟超阈值
binlog/Canal 延迟失效延迟持续增长
锁等待/超时强一致成本P99
脏数据抽样对账发现差异
TTL 剩余分布兜底能力异常
  • 深挖点(面试官常追的 6 个):

    1. 为什么是“删缓存”不是“更新缓存”:更新缓存看似少一次 miss,但两个并发写可能以错误顺序到达缓存:DB 最终是 v2,缓存却停在 v1。删除是幂等的,下一次读回源,天然避免“谁后写缓存谁赢”的乱序;代价是 cache miss 和回源压力。若一定要更新,需版本号/CAS/分布式锁。
    2. 延迟双删到底解决什么:它解决“读线程在缓存删除后把旧 DB 值回填”的窗口:更新 DB 后删一次,延迟再删一次,把并发读回填的旧值清掉。睡眠时间要覆盖一次“读 DB + 写缓存”的 P99,工程上常用异步延迟/多次删除;它降低概率,不保证强一致。先删后写 DB 的变体同样需要第二次删除。
    3. binlog + MQ 的可靠性:Canal 订阅 ROW binlog,按事务/行解析,投递 MQ,消费者删缓存。要处理 Canal HA、MQ 至少一次、消费幂等、按 key 分区保证顺序、失败重试/死信、binlog 过期导致位点丢失。TTL 仍是最后兜底;不要假设消息一定成功。
    4. 本地消息表/事务消息:业务写 DB 和写 outbox 在同一个本地事务,保证“业务成功则消息一定可投递”;relay 扫 outbox 投 MQ,消费者幂等删除。事务消息用 MQ 半消息 + 本地事务回查,效果类似。两者都比“先写 DB 再发 MQ”可靠,后者可能 DB 成功、MQ 失败。
    5. 读己之写与主从延迟:写 DB 后删缓存,紧接着读请求如果走从库,可能读到旧 DB 并回填旧缓存;即使缓存删了也没用。解决是写后短时间内读主、会话粘主、WAIT_FOR_EXECUTED_GTID_SET,或缓存新值带版本。只解决缓存删除、不解决主从延迟,一致性仍有洞。
    6. 强一致的代价:按 key 加分布式锁能把读回填/写 DB/删缓存串行化,但锁超时、死锁、Redis 故障、Redlock 争议都会引入新问题;版本号避免锁但增加 key 数量和读版本成本;2PC/XA 跨 MySQL/Redis 不现实。多数业务应明确“缓存最终一致 + TTL + 对账”,而不是追求不可能的强一致。
  • 追问链:

    1. Cache-Aside 是什么? → 读 miss 回源 DB 回填;写 DB 后删缓存。
    2. 为什么先写 DB 再删缓存? → 避免先删导致并发读回填旧值;DB 是事实源。
    3. 为什么删缓存不更新缓存? → 更新会乱序;删除幂等,下次读回源。
    4. 删缓存失败怎么办? → 重试、MQ 补偿、TTL、对账。
    5. 先删缓存再写 DB 行不行? → 有并发回填旧值风险,需延迟双删/版本。
    6. 延迟双删原理? → 更新后延迟再删,清掉并发读回填的旧值。
    7. 延迟多久? → 覆盖一次读 DB + 写缓存 P99,常见几百 ms,按业务测。
    8. 延迟双删能强一致吗? → 不能,只是降低概率。
    9. 事务提交前能删缓存吗? → 不推荐;回滚/并发读会脏;用 afterCommit。
    10. 事务里更新缓存? → 不推荐;回滚留脏数据。
    11. binlog 方案怎么做? → Canal 订阅 ROW binlog → MQ → 消费者删缓存。
    12. Canal 依赖什么? → binlog_format=ROW、复制权限、位点/GTID。
    13. MQ 消息丢了怎么办? → outbox/事务消息、重试、TTL、对账。
    14. 消费重复怎么办? → 删除幂等。
    15. 消费乱序怎么办? → 按 key 分区、版本号、TTL。
    16. 本地消息表? → 业务 + outbox 同事务,relay 投 MQ。
    17. 事务消息? → 半消息 + 本地事务 + 回查,最终一致。
    18. 分布式锁怎么做? → 按 key 加锁,串行化读回填/写 DB/删缓存。
    19. 分布式锁有什么问题? → 超时、死锁、单点、Redlock 争议、性能。
    20. 版本号方案? → DB version + key:v{version},旧 key 靠 TTL。
    21. 版本号怎么读? → 先取当前 version(DB/版本缓存),再读对应 key。
    22. 读己之写怎么保证? → 写后读主、粘性会话、GTID wait、缓存新值。
    23. 主从延迟影响缓存吗? → 会;读从库旧值回填旧缓存。
    24. 半同步能解决吗? → 降低丢写,不解决缓存/从库读延迟。
    25. 强一致能做吗? → 锁/版本/读主,代价大;多数业务最终一致。
    26. 2PC/XA 能跨 MySQL/Redis 吗? → 不现实;Redis 不支持 XA。
    27. 缓存穿透怎么办? → 空值缓存、布隆过滤器、参数校验。
    28. 缓存击穿怎么办? → 互斥/singleflight/逻辑过期/热点永不过期。
    29. 缓存雪崩怎么办? → TTL 抖动、多级缓存、限流降级。
    30. 和多级缓存怎么配合? → 本地 + Redis 都失效;MQ 广播 + 短 TTL + 版本。
    31. 本地缓存一致性? → pub/sub/MQ 失效、短 TTL、版本;接受最终一致。
    32. 热 key 怎么写? → 计数器分片、MQ 聚合、异步落库。
    33. 大 key 怎么删? → UNLINK、分批、lazyfree。
    34. 缓存宕机怎么办? → 限流、熔断、降级、DB 保护。
    35. 怎么发现不一致? → 抽样对账、版本/updated_at 比较、监控。
    36. 对账怎么做? → 定时抽样 DB/cache,差异删缓存/修复。
    37. 怎么测试? → 并发读写、延迟注入、消息丢失、回滚、缓存宕机。
    38. 缓存和 DB 双写能原子吗? → 不能;不要假装分布式事务。
    39. Write-Through/Write-Behind? → 缓存层写 DB;后者异步可能丢。
    40. 读多写少怎么选? → Cache-Aside + TTL + 删除。
    41. 写多读少怎么选? → 谨慎用缓存;写穿/异步/批量。
    42. 缓存要不要存空值? → 防穿透,短 TTL。
    43. TTL 怎么设? → 业务容忍度 + 兜底;加 jitter。
    44. 缓存 key 怎么设计? → 业务前缀、版本、租户、分片;避免大 key。
    45. Redis Cluster 影响? → key 分布/槽;多 key 同槽;失效消息按 key 路由。
    46. MySQL 主从切换影响? → 新主数据/GTID;缓存失效消息可能重复/乱序。
    47. 消息队列积压? → 扩容消费者、降级、TTL、告警。
    48. Canal 延迟? → 监控位点/GTID,扩容、并行、TTL。
    49. 业务能接受旧值多久? → 决定 TTL/方案;这是业务问题。
    50. 最终一致怎么验收? → 压测 + 故障注入 + 对账 + SLO。
  • 生产案例/取舍(示例,替换成你的项目):

    • 商品详情 Cache-Aside,写 DB 后删缓存 + TTL;大促前压测回源。
    • 并发读回填旧值导致价格短时错误;延迟双删 + 版本号修复。
    • 删缓存失败导致旧库存;改为 binlog + MQ 重试 + TTL 兜底。
    • DB 提交成功但 MQ 发送失败;改本地消息表,保证失效消息可投递。
    • 写后读从库读到旧值并回填;写后 1s 读主 + GTID wait。
    • 热点商品本地缓存与 Redis 不一致;MQ 广播失效 + 短 TTL。
    • 分布式锁串行化库存读写,吞吐下降;改库存分片 + 最终一致。
    • 缓存宕机打爆 DB;限流 + 熔断 + 降级返回旧值。
    • 大 key 删除阻塞;UNLINK + 分批。
    • 取舍:删缓存换简单/一致,代价是 miss;延迟双删换更低脏读概率,代价是延迟/复杂度;binlog 换解耦/可靠,代价是链路;锁换强一致,代价是性能;TTL 换兜底,代价是旧值窗口。
  • 易错点:

    • 认为 MySQL 和 Redis 双写能原子。
    • 认为先删缓存再写 DB 没问题。
    • 认为更新缓存比删缓存好。
    • 在事务提交前删缓存。
    • 在事务里更新缓存。
    • 删缓存失败不重试。
    • 认为延迟双删能强一致。
    • 睡眠时间拍脑袋。
    • 忽略读从库延迟回填旧值。
    • 认为半同步能解决缓存一致性。
    • 只用 TTL 不做主动失效。
    • 只用 MQ 不做 outbox,消息丢失。
    • 消费不幂等。
    • 不按 key 分区导致乱序。
    • 分布式锁没有超时/续期。
    • 认为 Redlock 绝对可靠。
    • 版本号方案不处理旧 key 清理。
    • 本地缓存只失效 Redis 不失效本地。
    • 忽略缓存击穿/穿透/雪崩。
    • 忽略大 key 删除阻塞。
    • 缓存宕机没有降级。
    • 不做对账/故障注入。
    • 把缓存当事实源。
    • 认为强一致没有性能代价。
  • 30 秒口述稿:

Redis 和 MySQL 双写,默认是 Cache-Aside:读 miss 回源 DB 回填,写先提交 DB 再删缓存;删缓存失败重试 + TTL。不要更新缓存,因为并发更新会乱序;不要在事务提交前删/更新缓存。并发读回填旧值用延迟双删、版本号或按 key 锁;跨服务用 binlog/Canal + MQ 或本地消息表/事务消息做可靠失效,消费幂等、按 key 分区、失败重试。读己之写还要处理主从延迟,写后读主/GTID wait。目标是最终一致,不是强一致。

  • 3 分钟展开顺序:结论(事实源 + 最终一致)→ Cache-Aside 读写 → 为什么删不更新 → 并发漏洞时间线 → 延迟双删/版本/锁 → binlog/MQ/outbox 可靠失效 → 读己之写/主从延迟 → 多级缓存/热大 key → 监控/对账/取舍。