Appearance
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 或事务消息做可靠失效。强一致要靠锁/版本/读主,代价是性能和复杂度。
分层要点:
- 先定一致性目标:MySQL 是事实源,Redis 是加速层。绝大多数业务接受“短暂旧值 + 最终一致”,用 TTL 兜底;金融/库存等强一致场景,要么读主/加锁/版本,要么不要让缓存参与关键判断。不要用“双写”假装原子,MySQL 和 Redis 没有跨库事务。
- 读路径 Cache-Aside:先读缓存,命中返回;未命中读 MySQL,再回填缓存。要防穿透(空值/布隆过滤器)、击穿(互斥/singleflight/逻辑过期)、雪崩(TTL 抖动),这些是 4.2-8 的问题,不要和双写一致性混为一谈。
- 写路径:先 DB 后删缓存:先提交 MySQL 事务,成功后再删除 Redis key;删除失败要重试/走补偿,不能吞掉。不要在事务提交前删缓存,也不要在事务里更新缓存:回滚会留下脏缓存,提交前删缓存会让并发读把旧值回填。
- 为什么删缓存而不是更新缓存:更新缓存会引入“两次更新到达顺序颠倒”的问题:T1 写 v1、T2 写 v2,但 T2 先更新缓存、T1 后更新,缓存停在 v1。删除是幂等的,下一次读会重新加载最新值;代价是一次 cache miss。
- 经典并发漏洞:先更新 DB 再删缓存,仍可能被“读未命中 → 读旧 DB → 写旧缓存”插队;先删缓存再更新 DB,也可能被“读未命中 → 回填旧值”插队。延迟双删是在更新后延迟再删一次,覆盖并发回填;但它不是强一致,睡眠时间要覆盖一次 DB 读 + 缓存写。
- 可靠失效:应用内删除失败不可靠,工程上用 binlog + Canal/Debezium + MQ 或 本地消息表/事务消息 驱动缓存删除;消息至少一次、消费幂等、失败重试 + 死信 + TTL。这样业务代码只写 DB,缓存失效由 CDC 异步完成,解耦且可补偿。
- 强一致手段:按 key 分布式锁把“读回填/写 DB/删缓存”串行化;或用版本号(DB version +
key:v{version})让旧缓存自然失效;或写后读主(避免从库延迟回填旧值)。锁有超时/单点/Redlock 争议,版本号有存储/读版本成本,读主有主库压力。 - 多级缓存与热点:本地缓存 + 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
└─ 失败 → 重试 / 死信 / TTLtext
本地消息表/事务消息:
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;Redismaxmemory-policy、TTL、UNLINK。 - 源码/实现:MySQL
sql/binlog.cc、sql/rpl_binlog_sender.cc;Redissrc/db.c(删除/过期)、src/t_string.c;Canalparse/sink/adapter。
- MySQL 5.6+/8.0:
缓存模式对比:
| 模式 | 读 | 写 | 一致性 | 适用 |
|---|---|---|---|---|
| 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 个):
- 为什么是“删缓存”不是“更新缓存”:更新缓存看似少一次 miss,但两个并发写可能以错误顺序到达缓存:DB 最终是 v2,缓存却停在 v1。删除是幂等的,下一次读回源,天然避免“谁后写缓存谁赢”的乱序;代价是 cache miss 和回源压力。若一定要更新,需版本号/CAS/分布式锁。
- 延迟双删到底解决什么:它解决“读线程在缓存删除后把旧 DB 值回填”的窗口:更新 DB 后删一次,延迟再删一次,把并发读回填的旧值清掉。睡眠时间要覆盖一次“读 DB + 写缓存”的 P99,工程上常用异步延迟/多次删除;它降低概率,不保证强一致。先删后写 DB 的变体同样需要第二次删除。
- binlog + MQ 的可靠性:Canal 订阅 ROW binlog,按事务/行解析,投递 MQ,消费者删缓存。要处理 Canal HA、MQ 至少一次、消费幂等、按 key 分区保证顺序、失败重试/死信、binlog 过期导致位点丢失。TTL 仍是最后兜底;不要假设消息一定成功。
- 本地消息表/事务消息:业务写 DB 和写 outbox 在同一个本地事务,保证“业务成功则消息一定可投递”;relay 扫 outbox 投 MQ,消费者幂等删除。事务消息用 MQ 半消息 + 本地事务回查,效果类似。两者都比“先写 DB 再发 MQ”可靠,后者可能 DB 成功、MQ 失败。
- 读己之写与主从延迟:写 DB 后删缓存,紧接着读请求如果走从库,可能读到旧 DB 并回填旧缓存;即使缓存删了也没用。解决是写后短时间内读主、会话粘主、
WAIT_FOR_EXECUTED_GTID_SET,或缓存新值带版本。只解决缓存删除、不解决主从延迟,一致性仍有洞。 - 强一致的代价:按 key 加分布式锁能把读回填/写 DB/删缓存串行化,但锁超时、死锁、Redis 故障、Redlock 争议都会引入新问题;版本号避免锁但增加 key 数量和读版本成本;2PC/XA 跨 MySQL/Redis 不现实。多数业务应明确“缓存最终一致 + TTL + 对账”,而不是追求不可能的强一致。
追问链:
- Cache-Aside 是什么? → 读 miss 回源 DB 回填;写 DB 后删缓存。
- 为什么先写 DB 再删缓存? → 避免先删导致并发读回填旧值;DB 是事实源。
- 为什么删缓存不更新缓存? → 更新会乱序;删除幂等,下次读回源。
- 删缓存失败怎么办? → 重试、MQ 补偿、TTL、对账。
- 先删缓存再写 DB 行不行? → 有并发回填旧值风险,需延迟双删/版本。
- 延迟双删原理? → 更新后延迟再删,清掉并发读回填的旧值。
- 延迟多久? → 覆盖一次读 DB + 写缓存 P99,常见几百 ms,按业务测。
- 延迟双删能强一致吗? → 不能,只是降低概率。
- 事务提交前能删缓存吗? → 不推荐;回滚/并发读会脏;用 afterCommit。
- 事务里更新缓存? → 不推荐;回滚留脏数据。
- binlog 方案怎么做? → Canal 订阅 ROW binlog → MQ → 消费者删缓存。
- Canal 依赖什么? →
binlog_format=ROW、复制权限、位点/GTID。 - MQ 消息丢了怎么办? → outbox/事务消息、重试、TTL、对账。
- 消费重复怎么办? → 删除幂等。
- 消费乱序怎么办? → 按 key 分区、版本号、TTL。
- 本地消息表? → 业务 + outbox 同事务,relay 投 MQ。
- 事务消息? → 半消息 + 本地事务 + 回查,最终一致。
- 分布式锁怎么做? → 按 key 加锁,串行化读回填/写 DB/删缓存。
- 分布式锁有什么问题? → 超时、死锁、单点、Redlock 争议、性能。
- 版本号方案? → DB version +
key:v{version},旧 key 靠 TTL。 - 版本号怎么读? → 先取当前 version(DB/版本缓存),再读对应 key。
- 读己之写怎么保证? → 写后读主、粘性会话、GTID wait、缓存新值。
- 主从延迟影响缓存吗? → 会;读从库旧值回填旧缓存。
- 半同步能解决吗? → 降低丢写,不解决缓存/从库读延迟。
- 强一致能做吗? → 锁/版本/读主,代价大;多数业务最终一致。
- 2PC/XA 能跨 MySQL/Redis 吗? → 不现实;Redis 不支持 XA。
- 缓存穿透怎么办? → 空值缓存、布隆过滤器、参数校验。
- 缓存击穿怎么办? → 互斥/singleflight/逻辑过期/热点永不过期。
- 缓存雪崩怎么办? → TTL 抖动、多级缓存、限流降级。
- 和多级缓存怎么配合? → 本地 + Redis 都失效;MQ 广播 + 短 TTL + 版本。
- 本地缓存一致性? → pub/sub/MQ 失效、短 TTL、版本;接受最终一致。
- 热 key 怎么写? → 计数器分片、MQ 聚合、异步落库。
- 大 key 怎么删? →
UNLINK、分批、lazyfree。 - 缓存宕机怎么办? → 限流、熔断、降级、DB 保护。
- 怎么发现不一致? → 抽样对账、版本/updated_at 比较、监控。
- 对账怎么做? → 定时抽样 DB/cache,差异删缓存/修复。
- 怎么测试? → 并发读写、延迟注入、消息丢失、回滚、缓存宕机。
- 缓存和 DB 双写能原子吗? → 不能;不要假装分布式事务。
- Write-Through/Write-Behind? → 缓存层写 DB;后者异步可能丢。
- 读多写少怎么选? → Cache-Aside + TTL + 删除。
- 写多读少怎么选? → 谨慎用缓存;写穿/异步/批量。
- 缓存要不要存空值? → 防穿透,短 TTL。
- TTL 怎么设? → 业务容忍度 + 兜底;加 jitter。
- 缓存 key 怎么设计? → 业务前缀、版本、租户、分片;避免大 key。
- Redis Cluster 影响? → key 分布/槽;多 key 同槽;失效消息按 key 路由。
- MySQL 主从切换影响? → 新主数据/GTID;缓存失效消息可能重复/乱序。
- 消息队列积压? → 扩容消费者、降级、TTL、告警。
- Canal 延迟? → 监控位点/GTID,扩容、并行、TTL。
- 业务能接受旧值多久? → 决定 TTL/方案;这是业务问题。
- 最终一致怎么验收? → 压测 + 故障注入 + 对账 + 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 → 监控/对账/取舍。