张彦峰ZYF头像
先挡流量再保一致:工程级缓存的更新时序、竞态窗口、五类热门问题与本地缓存+双缓存主备架构解析封面图

先挡流量再保一致:工程级缓存的更新时序、竞态窗口、五类热门问题与本地缓存+双缓存主备架构解析

目录

一、先问要不要缓存:把账算清再囤粮

(一)缓存解决的是哪一类问题

(二)引入缓存要付的四笔账

(三)一个可执行的引入判据

二、两类缓存的分工:进程内与分布式

(一)本地缓存:快,但各自为政

1、从 HashMap 到 Caffeine

2、多实例部署带来的三个问题

(二)分布式缓存:共享视图,代价是网络

(三)二级缓存的组合方式

三、三种更新模式:谁来维护缓存

(一)旁路缓存(Cache Aside):应用自己管

1、读路径与写路径

2、为什么是“删缓存”而不是“更新缓存”

(二)读写穿透(Read/Write Through):交给缓存组件

(三)异步写回(Write Behind):先进缓存再慢慢落库

1、flush 的触发与合并

2、丢数据与乱序:WAL、幂等与背压

(四)三种模式怎么选

四、更新时序与竞态窗口:把“概率很小”算出来

(一)四种写法的经典反例

1、先删缓存再更新库:读请求把旧值写回去

2、先更新库再更新缓存:两个写请求乱序覆盖

3、先更新库再删缓存:也会脏,只是窗口更窄

(二)一次蒙特卡洛实验

1、实验设定

2、读主库时的结果

3、读从库与写写并发时的结果

(三)三个容易被忽略的放大器

(四)延迟双删、binlog 订阅与版本墓碑

1、延迟双删的间隔怎么定

2、binlog 订阅:删除必达,但不是时序万能药

3、版本号与墓碑:从根上拒绝旧值回填

五、一致性方案:强一致的代价与最终一致的工程做法

(一)不一致从哪里来

(二)强一致:能做,但要想清楚代价

(三)最终一致:让删除一定发生

1、业务内重试 + 消息队列

2、订阅 binlog

3、事务外发表(Outbox)

(四)兜底:TTL、校对与可观测

六、五类热门问题:穿透、雪崩、击穿、热点 key、大 key

(一)缓存穿透:查一个根本不存在的 key

1、空值缓存与布隆过滤器

2、入口校验与限流

(二)缓存雪崩:同一时刻大批 key 一起失效

(三)缓存击穿:一个热 key 过期的那一瞬间

(四)热点 key:再多的分片也只有一个在扛

1、为什么扩容没用

2、治理手段

3、先发现,才谈得上治理

(五)大 key:一个 key 堵住整条队

1、为什么危害大

2、怎么认定与发现

3、怎么治理

七、复杂工程方案:本地缓存 + 双缓存主备

(一)整体分层

(二)策略层:降级、兜底、报警

1、降级

2、兜底

3、报警

(三)查询流程

1、主备切换与熔断

2、故障演练:熔断器决定了“慢故障”有多疼

3、异步加载不强求成功

(四)更新流程

1、数据总线驱动删除

2、部分成功的风险

3、实验:重试和校对各管一段

4、低峰期校对

(五)本地缓存的失效广播

(六)这套方案的代价与适用边界

八、落地清单与结论

(一)上线前检查清单

(二)结论与适用范围

参考链接


干货分享,感谢您的阅读!

“加一层缓存”几乎是每个高并发系统的第一反应,但真正把缓存用稳的团队并不多。线上出过的缓存事故大致分两类:一类是挡不住——热 key 过期瞬间把数据库打满、大批 key 同时失效形成雪崩、不存在的 ID 被刷成穿透;另一类是对不上——数据库已经改了,缓存里还是旧值,而且一脏就是一个 TTL。前者考验的是缓存的“挡流量”能力,后者考验的是“保一致”能力,两者经常互相牵制:为了挡流量把 TTL 拉长,旧值就活得更久;为了保一致频繁删缓存,回源压力又上来了。

这篇文章想把这两件事放在一张图里讲清楚,具体回答五个问题:

  1. 什么时候才值得引入缓存,本地缓存和分布式缓存各自适合放什么;
  2. 三种缓存更新模式(旁路缓存、读写穿透、异步写回)的取舍;
  3. “先更新库再删缓存”到底有多安全——不是凭直觉说“概率很小”,而是用仿真把不同写法的脏数据概率算出来,并找出放大它的因素;
  4. 穿透、雪崩、击穿、热点 key、大 key 五类热门问题各用什么手段、代价是什么;
  5. 面对高流量且强依赖缓存的平台,“本地缓存 + 双缓存主备” 这套工程方案怎么设计查询、更新、降级与校对,它真正能扛住什么、扛不住什么。

文中的数字来自三组可复现的实验(代码在交付包 code/cache-lab 目录):

  • RaceWindowSim:虚拟时间蒙特卡洛,比较六种更新写法在读主库、读从库、写写并发下的“滞留脏值”概率;
  • StampedeSim:击穿(五种保护方案)、雪崩(TTL 抖动)、穿透(真实 Guava BloomFilter)的对照;
  • DualCacheLab:用 Caffeine 2.9.3 做本地缓存、内存模拟两套远程缓存,真实多线程地实现主备切换、熔断、单飞、数据总线重试与校对,并做故障演练。

实验环境为 macOS(12 核)+ Zulu JDK 1.8.0_322,依赖 Guava 32.0.1-jre、Caffeine 2.9.3;仿真类实验结果固定种子可复现,多线程实验每次运行会有一两成波动,文中注明的是其中一次的结果。文中提到的 Redis 命令与特性会标注起始版本。

一、先问要不要缓存:把账算清再囤粮

家里囤米面油是个好比方:附近超市随时买得到、家里人口不多,就没必要一口气囤半年的粮——占地方,还会过期;只有预计要来很多客人,或者超市要关门装修几个月,大规模囤粮才划算。缓存也是这样,它是为具体瓶颈准备的,而不是架构图上的标配。

(一)缓存解决的是哪一类问题

缓存能带来的收益可以归成三类,评审时最好明确说出是哪一类:

  • 降延迟:把一次 5~50ms 的数据库查询(甚至是跨库聚合、调用外部接口)换成 0.2~1ms 的 Redis 往返,或者微秒级的进程内读取。对单次查询代价很高的场景,哪怕请求量不大,缓存也可能是满足延迟指标的必要手段。
  • 扛吞吐:数据库的连接数、CPU、磁盘 IO 都有上限,读请求在缓存层被消化掉,数据库只承接写入和少量回源。
  • 挡流量、保护下游:缓存和限流、降级一起被称为高并发系统的三件保护利器。大促、热点事件时,缓存层是数据库前面的第一道堤坝。

反过来,下面这些情况引入缓存往往得不偿失:数据库本身还有很大余量、慢查询可以靠索引解决;数据写多读少、命中率注定很低;数据要求“改了马上看到”,而业务又无法接受任何旧值;后台管理、低频配置这类访问量很小的功能——给它们加缓存,换来的是每次修改都要处理刷新、过期和多环境同步,维护成本比查一次数据库高得多。

还要意识到,“缓存”从来不只是 Redis。一次请求从用户到数据库,沿途可能经过浏览器缓存、CDN、网关缓存、进程内缓存、分布式缓存五层。越靠近用户,命中一次越便宜,但失效越难控制(CDN 上的内容要靠主动刷新或等过期);越靠近数据,越准确,但每次访问越贵。本文聚焦服务端的后两层:进程内缓存和分布式缓存,但排查问题时要记得把各层的命中率、回源量分开统计——只盯 Redis 命中率,很可能漏掉“CDN 缓存时间太短、流量根本没在边缘被拦住”这类问题。

(二)引入缓存要付的四笔账

缓存的性能收益很直观,代价却经常被低估。至少有四笔账要在评审阶段写清楚:

一致性账。数据有了两份,就必然存在两份不一样的窗口期。要回答的不是“会不会不一致”,而是“允许旧多久”“不一致了怎么发现、怎么修复”。

可用性账。缓存挡在数据库前面,它就成了一个新的依赖。缓存抖动、宕机、扩容迁移、网络分区都会传导到业务:命中率突然下降,回源量就会成倍上涨。一个缓存方案是否成熟,很大程度上看它在缓存故障时的表现。

容量账。内存、网卡带宽、序列化与反序列化的 CPU 都是成本。热 key 会让单个分片的网卡先打满,大 key 会让单线程的命令执行变慢——这些都不是“加机器”能直接解决的。

运维账。预热、监控(命中率、回源 QPS、调用耗时、错误率)、降级开关、故障演练,每一项都需要有人维护。没有监控的缓存,出问题时只能凭感觉猜。

(三)一个可执行的引入判据

把上面两节合起来,可以得到一个评审时能直接用的判据:

判断项建议引入缓存建议先不引入
数据库是否已成瓶颈压测或监控显示 CPU、连接数、慢查询已逼近上限还有明显余量,或能靠索引、SQL 优化解决
读写比读远多于写(常见经验值 10:1 以上)写多读少,命中率注定很低
可容忍的旧值时长秒级、分钟级旧值业务可以接受必须读到最新值(余额、库存扣减)
单次查询代价跨库聚合、复杂计算、外部接口调用主键查询、几毫秒就能返回
峰值与均值之比大促、热点事件下峰值远超数据库能力流量平稳且远低于数据库能力

只要“建议引入”那一栏占了多数,再去讨论用哪种缓存、怎么更新、怎么降级;否则,先把数据库用好。

二、两类缓存的分工:进程内与分布式

(一)本地缓存:快,但各自为政

1、从 HashMap 到 Caffeine

最简单的本地缓存是一个 HashMap,但它离“可用的缓存”还差很远:不是线程安全的;没有容量上限,只写不删会一直涨到 OOM;没有过期;也没有命中率统计。换成 ConcurrentHashMap 只解决了并发安全这一项。生产环境应该用专门的缓存库:Guava Cache 是老牌选择,Guava 官方现在推荐用它的继任者 Caffeine——后者用 W-TinyLFU 做淘汰决策,在多数负载下命中率接近理论最优,并发读写的开销也更低。

需要注意版本:Caffeine 3.x 要求 Java 11 及以上,Java 8 项目只能停在 2.9.x(本文实验用的就是 2.9.3)。一个典型的本地缓存配置如下:

// 适用:Caffeine 2.9.x(Java 8)与 3.x(Java 11+),API 相同
Cache<String, ProductView> local = Caffeine.newBuilder()
        .maximumSize(10_000)                         // 按条数限容;对象大小差异大时改用 maximumWeight + weigher
        .expireAfterWrite(Duration.ofSeconds(5))     // 本地副本只活几秒:它是“旧值寿命”的上限
        .recordStats()                               // 打开命中率统计,接入监控
        .build();

这段配置里最关键的是 expireAfterWrite:本地缓存通常无法做到精确失效,所以它的 TTL 就是“最坏情况下旧值能活多久”。后面讲双缓存方案时会看到,失效广播负责“快”,TTL 负责“兜底”。

2、多实例部署带来的三个问题

本地缓存的优势是快:一次读取在微秒级,没有网络往返、没有序列化。但应用一旦部署成多个实例,它就会暴露三个问题:

  • 副本不一致。每个实例各有一份,商品价格在 A 实例已经刷新、B 实例还是旧的,用户刷新两次页面看到两个价格。更麻烦的是各实例的过期时间不同步,排查时很难复现。
  • 吃堆内存、影响 GC。缓存对象长期存活,会进入老年代;容量设大了,Full GC 或老年代回收的成本也跟着上去。大对象还会加剧晋升压力。
  • 冷启动。实例重启或扩容后缓存是空的,新实例的流量会全部打到下游,弹性扩容越频繁,这个问题越明显。

所以本地缓存适合放的是:极热、少变、能容忍秒级旧值的数据,比如数据字典、配置、商品类目、开放平台的 API 元信息。会频繁变化、需要秒级生效的数据(订单状态、账户信息),最好收敛到分布式缓存。

(二)分布式缓存:共享视图,代价是网络

Redis、Tair 这类分布式缓存把数据放在独立的缓存集群里,所有应用实例看到的是同一份数据,容量可以通过分片横向扩展。它的代价是每次访问都有一次网络往返(同机房通常 0.2~1ms),再加上序列化、连接池等开销;而且它是所有实例共享的,一个热 key、一个大 key、一次扩容迁移,影响的是全体调用方。

分布式缓存内部的分片、副本、路由机制(比如 Tair 的 bucket 与对照表)属于另一个话题,本文只把它当作一个“可能变慢、可能宕机、可能丢删除”的远程依赖来对待。

(三)二级缓存的组合方式

把两者叠起来,就是常说的二级缓存:本地缓存(L1)挡住最热的那一小撮 key,分布式缓存(L2)挡住剩下的大部分,数据库只接漏下来的请求。本文 DualCacheLab 的正常阶段给了一个直观的数字:2 万个 key、Zipf 分布访问、每个实例的 Caffeine 只放 2000 条,L1 命中 69.4%,L2 命中 30.6%,回源接近 0——不到一成的 key 挡住了七成的流量,这正是热点分布下本地缓存的价值。

组合时有三条经验:

  1. L1 的 TTL 要短(秒级),并配合变更广播主动失效;L2 的 TTL 可以长一些,但删除必须可靠。
  2. L1 只放“读了很多次、几乎不改”的数据,不要把整个 L2 镜像进进程。
  3. 回源时按 key 合并请求(单飞),否则 L1、L2 同时失效的瞬间,每个实例的每个线程都会去查一次数据库。

三、三种更新模式:谁来维护缓存

缓存放在数据库前面,读请求被挡住了,但写入时“谁来保证两份数据对得上”成了新问题。常见的答案有三种。

(一)旁路缓存(Cache Aside):应用自己管

1、读路径与写路径

旁路缓存没有单独的缓存维护组件,由应用自己负责:

  • 读:先查缓存,命中直接返回;未命中则查数据库,把结果回填缓存后返回。
  • 写:先更新数据库,事务提交成功后,删除对应的缓存 key(而不是把新值写进缓存)。

用 Spring 与 Redis 写出来大致是这样(示意代码,省略了序列化与异常分类):

public ProductView get(long id) {
    String key = "product:" + id;
    ProductView v = redis.get(key);
    if (v != null) return v;                     // 命中
    v = productDao.findView(id);                 // 未命中:回源
    if (v != null) {
        // TTL 加随机抖动,避免同一批 key 同时过期(见第六章)
        redis.setex(key, 600 + ThreadLocalRandom.current().nextInt(120), v);
    }
    return v;
}

@Transactional
public void updatePrice(long id, long price) {
    productDao.updatePrice(id, price);
    // 删除动作必须放在事务提交之后,否则别的线程可能在提交前回源读到旧值并写回
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
        @Override public void afterCommit() { cacheInvalidator.delete("product:" + id); }
    });
}

这段代码有两个细节值得强调。第一,删除放在 afterCommit 里:如果在事务提交前就删了缓存,另一个线程可能在这个空档回源,读到的仍是未提交前的旧值,再写回缓存,脏数据就会活到 TTL 结束。第二,cacheInvalidator.delete 不应该是一次“删了就算”的调用——网络超时、Redis 抖动都会让删除失败,它需要重试或兜底,这是第五章的主题。

2、为什么是“删缓存”而不是“更新缓存”

写入时直接把新值 SET 进缓存,看起来更“实时”,但有两个问题。一是并发写会乱序:两个写请求 A、B 先后提交数据库,数据库最终是 B 的值;但如果 A 在“提交”和“写缓存”之间被 GC 停顿或网络抖动拖慢,缓存最后收到的是 A 的旧值,而且会一直脏下去。二是违背懒加载:很多缓存值是聚合计算的结果,每次写都重算一遍,可能根本没人读。删除则简单得多——下一次读自然会从数据库加载最新值。

第四章会用仿真比较这两种写法,结论会比“删除更好”更细一些:在读主库、写入不频繁时,两者的脏数据概率相近;真正拉开差距的是写写并发和读从库。

(二)读写穿透(Read/Write Through):交给缓存组件

旁路缓存的问题是缓存逻辑散落在业务代码里:每个查询都要写“查缓存、查库、回填”,加负缓存、加逻辑过期时要改一大片。读写穿透在中间抽出一层缓存管理组件,业务只和它打交道,缓存与数据库对业务来说是一个整体:

  • 读穿透:组件查缓存,未命中时由组件查数据库并回填,再返回给应用。
  • 写穿透:组件同步更新数据库和缓存,两边都完成才返回成功。

抽出组件的好处不只是少写几行代码,更重要的是 TTL、序列化、命中率监控、降级规则可以集中治理。代价也很明确:组件需要知道怎么读写数据库(通常是注册回源函数);它必须自带单飞、空值缓存、熔断降级,否则热 key 过期时组件会替所有调用方一起把数据库打穿;而且组件一旦出问题,所有业务一起受影响。经验上,配置、类目这类稳定的基础数据很适合穿透模式;规则复杂、更新链路长的业务数据,旁路缓存反而更方便按领域定制。

(三)异步写回(Write Behind):先进缓存再慢慢落库

1、flush 的触发与合并

异步写回和写穿透的结构一样,区别在于同步与否:写请求只更新缓存就返回,落库由后台异步完成,这个过程叫 flush。flush 的触发条件可以自定义——每隔一秒、攒够 500 条、或者两者取先到者;同一个 key 在一个周期内被改了多次,只需要落最后一次。读写都只和缓存交互,吞吐最高。

2、丢数据与乱序:WAL、幂等与背压

异步写回的难点不在“异步”,而在“怎么证明没丢、没乱”:

  • flush 前宕机就会丢数据。缓存节点重启、进程发布时,内存里待落库的数据一起消失。补救是先把变更写入持久化日志(WAL 或持久化队列),落库成功才确认。
  • 重复 flush 会让计数翻倍。重试和重复消费都可能把同一批数据写两次,落库要以事件 ID 或业务键做幂等。
  • 数据库变慢时缓存会无限堆积。所谓高吞吐只是把故障延后爆发,必须有背压:积压超过阈值时拒绝写入或降级,并对队列长度、最老任务年龄、失败重试次数设告警。
  • 同一 key 的多次更新要保序,按业务键分区消费,保证最终落库的是最新版本。

正因为这些复杂度,异步写回只适合允许最终一致、能容忍少量丢失或能重放的数据:计数、埋点聚合、统计类指标。订单、余额、库存这类核心交易数据不要用它。

(四)三种模式怎么选

维度旁路缓存读写穿透异步写回
谁维护缓存应用自己缓存组件缓存组件
写入何时返回数据库提交、删缓存之后数据库与缓存都写完之后缓存写完即返回
一致性最终一致,窗口小较强(同步双写)最弱,可能丢数据
写性能一般一般最好(可合并、批量)
实现复杂度低中高
典型场景读多写少的业务数据配置、类目等稳定基础数据计数、埋点、统计聚合

三种模式不是谁比谁先进,而是在“代码复杂度、一致性、写入性能”三个维度上找平衡点。实践中最常见的是旁路缓存,下面两章也以它为主线展开。

四、更新时序与竞态窗口:把“概率很小”算出来

关于“先更新库再删缓存”,最常见的说法是:理论上也会脏,但需要“读请求比写请求先查库、又比写请求后回填”,而数据库读通常比写快,所以概率很小。这句话方向没错,但“很小”是多小?什么情况下会变大?这一章先看四种写法的经典反例,再用仿真把概率算出来。

(一)四种写法的经典反例

1、先删缓存再更新库:读请求把旧值写回去

写请求 A 先删除缓存成功;还没来得及更新数据库,读请求 B 来了,缓存未命中,从数据库读到旧值 v1 并回填;随后 A 才把数据库更新为 v2。结果缓存是 v1、数据库是 v2,一直脏到 TTL 过期。这个窗口等于 A 的整个数据库事务时长(通常几毫秒到几十毫秒),对每秒几百次读的热 key 来说,几乎必然会有读请求落进去。

2、先更新库再更新缓存:两个写请求乱序覆盖

数据库按提交顺序生效,缓存按 SET 到达的顺序生效,两者之间没有任何约束。A、B 先后提交,数据库最终是 v2;但 A 在两步之间被拖慢,最后到达缓存的是 v1。除了乱序,它还有懒加载的问题:缓存值如果需要聚合计算,每次写都重算一次,可能根本没人读。

3、先更新库再删缓存:也会脏,只是窗口更窄

读请求 A 恰好遇到缓存过期,去数据库读到旧值 v1;这时写请求 B 提交了 v2 并删除缓存;A 这才把 v1 回填进去。要发生这件事,A 的“查库到回填”必须完整地跨过 B 的“提交到删除”。正常情况下 A 查库只要两三毫秒,确实不容易跨过去;但只要 A 在中间遇到一次 GC 停顿、一次慢查询,或者 A 读的是从库,窗口就会被成倍放大。

(二)一次蒙特卡洛实验

1、实验设定

RaceWindowSim 用虚拟时间模拟一个热点 key 的一次(或两次并发)写入,前后有每秒 500 次的读请求按泊松过程到达。每轮先生成一套完整场景——到达时刻、每段耗时、是否遇到停顿、删除是否失败——再让六种写法在同一套场景上各跑一遍,比较的就只是写法本身。主要参数:

  • 主库读耗时:对数正态,中位 2ms;0.5% 的读是慢查询,额外多出 100~500ms。
  • 写事务耗时:中位 8ms;同一行的两个写由行锁串行化,后到者至少比前者晚 1ms 提交。
  • 应用线程在“拿到结果”和“操作缓存”之间:通常 0.3ms,1% 的概率遇到 50~300ms 停顿(GC、线程调度)。
  • 从库复制延迟:中位 20ms,1% 超过 300ms;binlog 订阅链路再加中位 40ms。
  • 同步删除失败率 0.2%(超时)。写入前缓存一半概率有旧值、一半概率刚过期。

六种写法:A 先更新库再更新缓存;B 先删缓存再更新库;C 先更新库再删缓存;D 在 C 的基础上提交后 500ms 再删一次(延迟双删);E 在 C 的基础上订阅从库 binlog 再删一次(删除必达);F 版本墓碑——提交后写一个带版本号的失效标记,回填时比较版本,旧版本一律拒绝(下一节详述)。

指标是滞留脏值概率:所有动作结束后缓存里留下的是旧版本、只能等 TTL 过期自愈的轮次占比。每个场景 2 万轮,种子固定,结果可复现。

2、读主库时的结果

写法场景一:读主库·单写场景二:读从库·单写场景三:读主库·写写并发场景四:读从库·写写并发
A 先更新库再更新缓存1.78%1.78%2.77%2.77%
B 先删缓存再更新库88.07%99.74%92.94%99.95%
C 先更新库再删缓存1.72%93.69%14.64%96.44%
D C + 延迟双删 500ms0.005%0.91%0.015%1.66%
E C + 从库 binlog 删除1.18%4.09%2.93%5.92%
F 版本墓碑 + 条件回填0%0%0%0%

先看场景一。B 的 88% 说明,对热 key 而言“先删后改”几乎是必脏的,因为写事务的几毫秒里一定有读请求进来。C 的 1.72% 印证了“概率小”的说法,但它并不是零:每 60 次写入就有一次留下脏值,对每天改价几万次的商品中心来说,就是每天上千个脏 key。A 在这里与 C 相差无几——它的问题要到写写并发时才暴露。

3、读从库与写写并发时的结果

场景二把读请求改成读从库,C 从 1.72% 直接跳到 93.69%:删除发生在主库提交后约 1ms,而从库还要二十毫秒才追上,这期间未命中的读请求从从库读到旧值、回填进去,删除早已发生过了。这就是“读写分离 + Cache Aside”最常见的事故形态,也是很多团队“明明删了缓存还是脏”的根源。

场景三是同一行在 20ms 内被改了两次。C 升到 14.64%:第一个写删除缓存后,一批读请求涌进来读到“第一个写的值”,而第二个写在 1ms 后就提交并删除了,这些读请求的回填正好落在第二次删除之后。A 只升到 2.77%,此时 A 反而比 C 稳——这提醒我们,“删除优于更新”的结论成立的前提是写写并发不多,或者后面还有兜底。

(三)三个容易被忽略的放大器

把 C 单独拿出来做敏感性分析(读主库、写入前缓存刚过期):

应用停顿概率0%0.1%1%5%
C 的滞留脏值概率1.53%1.73%3.61%11.05%

即便没有任何停顿,C 仍有 1.53%,来自慢查询和删除失败;而停顿概率从 1% 升到 5%(比如服务正在经历频繁 GC),脏值概率翻了三倍。归纳下来,放大竞态窗口的有三类因素:

  1. 应用侧停顿:GC、线程池排队、CPU 争抢,把“拿到查询结果”和“回填缓存”之间的距离拉长。
  2. 数据库慢查询与锁等待:读请求在数据库里待得越久,越可能跨过写请求的提交与删除。
  3. 读从库:复制延迟直接成为窗口的一部分,而且是数量级上的放大。

这也解释了为什么同一套代码在测试环境从不出问题、上线后偶发脏数据:测试环境既没有从库延迟,也很少有长 GC。

(四)延迟双删、binlog 订阅与版本墓碑

1、延迟双删的间隔怎么定

D 在场景二里把 C 的 93.69% 压到 0.91%,代价是每次写多一次删除、多一些回源(回源次数从每轮 3.6 次升到 6.0 次)。关键在间隔:

第二次删除距提交50ms200ms500ms1000ms
滞留脏值概率(读从库)22.61%5.04%0.91%0.04%

间隔必须覆盖“从库复制延迟 + 一次读请求的查库与回填耗时”的高分位。复制延迟本身是长尾的,所以延迟双删永远只能把概率压低,而无法归零;同时,实现上要把第二次删除放进延迟队列或定时任务,而不是在业务线程里 sleep。

2、binlog 订阅:删除必达,但不是时序万能药

E 的价值在于删除必达:订阅组件按 binlog 删除,失败就重投,不怕业务进程在删除前崩溃。但在场景二里它仍有 4.09%,比 D 还高——订阅链路的 40ms 并不足以覆盖所有慢读请求的回填。换句话说,binlog 订阅本质上是“一次可靠的、延迟时间不受控的延迟删除”。想让它同时覆盖复制延迟,应该订阅读请求所读的那个从库的 binlog,或者在消费端再加一段固定延迟。

3、版本号与墓碑:从根上拒绝旧值回填

前面所有写法的共同弱点是:缓存不知道自己收到的回填是新是旧。F 的思路是让每条数据带上版本号(行上的 version 字段或更新时间戳),删除时不真的删掉 key,而是写入一个带版本号的墓碑;回填时用 Lua 在 Redis 里原子比较,旧版本一律拒绝:

-- KEYS[1] = 缓存 key;ARGV[1] = 回填的版本号;ARGV[2] = 序列化后的值;ARGV[3] = TTL 秒
-- 缓存内用 Hash 存 v(版本)、t(是否墓碑)、d(数据)
local cur = redis.call('HMGET', KEYS[1], 'v', 't')
local ver = tonumber(ARGV[1])
if cur[1] then
  local cv = tonumber(cur[1])
  if cur[2] == '1' then
    if ver < cv then return 0 end      -- 墓碑:新版本必须 >= 墓碑版本
  elseif ver <= cv then return 0 end   -- 数据:新版本必须 > 已有版本
end
redis.call('HSET', KEYS[1], 'v', ver, 't', '0', 'd', ARGV[2])
redis.call('EXPIRE', KEYS[1], tonumber(ARGV[3]))
return 1

写入侧对应的“删除”变成:HSET key v <新版本> t 1 并设置一个较短的 TTL(比如 60 秒,足以覆盖复制延迟与慢读)。读取时遇到墓碑当作未命中处理。四个场景下 F 的滞留脏值概率都是 0,代价有两个:一是读从库时,墓碑存在期间从库读到的旧值都会被拒绝,这些请求只能继续回源——实验里每轮回源次数从 6.0 次升到 25.5 次;二是每条数据都要能拿到可靠的版本号,跨表聚合出来的缓存值往往不好定义版本。

Facebook 在 2013 年的 Memcache 论文里用的“租约”(lease)是同一思路的另一种实现:缓存未命中时发给读请求一个令牌,期间若有删除则令牌作废,回填时令牌无效就拒绝写入;同一个令牌机制还顺带限制了同一 key 的并发回源,缓解了热 key 击穿。

五、一致性方案:强一致的代价与最终一致的工程做法

(一)不一致从哪里来

把上一章的现象往下追,缓存与数据库不一致的根因可以分成两层:

  • 业务层面:更新顺序选错;并发读写交错;删除放在事务提交之前;缓存操作与数据库操作无法放进同一个事务,只能分开处理。如果为了一致性把缓存更新塞进数据库事务里,又会拉长事务、长时间占用数据库连接,得不偿失。
  • 系统层面:缓存节点故障或网络分区导致删除失败;删除请求超时(到底删没删都不知道);主从复制延迟;应用 GC 停顿、慢查询放大竞态窗口。

业务层面的问题可以靠“选对顺序”缩小窗口,但系统层面的失败是任何顺序都无法消除的。所以完整的一致性方案一定由两部分组成:缩小窗口的写法,加上发现并修复不一致的兜底。

(二)强一致:能做,但要想清楚代价

从强到弱,常见的做法排成一条光谱:

  1. 不走缓存,直接读权威数据源。最强,也最贵。余额扣减、库存锁定这类“读到旧值就会出错”的操作,应该缩小缓存的职责,关键判断直接读数据库。
  2. 同 key 串行化。用分布式读写锁或按 key 路由到同一个队列,让同一 key 的读回填与写删除不再交错。它能保证强一致,但吞吐下降、延迟上升,锁服务本身也成了新的依赖。两阶段提交理论上也能把缓存纳入事务,但主流缓存不支持 XA,工程上几乎不用。
  3. 版本号条件回填 + 删除必达。上一章的 F,能把“滞留脏值”降到零,但读请求在复制延迟期间仍可能读到从库旧值(这是读写分离本身的问题,与缓存无关)。
  4. 先更新库再删缓存 + 重试或 binlog 兜底。最终一致的主流做法,窗口很小且有修复路径。
  5. 只靠 TTL。最弱,旧值最长活一个 TTL,适合榜单、推荐、统计展示这类“晚几分钟无所谓”的数据。

选哪一档,取决于业务对旧值的容忍度。与其笼统地承诺“最终会一致”,不如把窗口有多大、靠什么修复、多久修复写进设计文档。

(三)最终一致:让删除一定发生

最终一致方案的核心是“删除必达”。常见的三条链路如下。

1、业务内重试 + 消息队列

数据库更新成功后删除缓存,失败就把 key 写入 MQ,由消费者重试删除。它的问题是重试逻辑侵入业务代码,而且“数据库提交成功、进程恰好崩溃、还没来得及发 MQ”这种情况无法覆盖。同步重试还是异步补偿也要权衡:同步重试会拉长接口耗时,异步补偿会留下一段旧值窗口。一个常见折中是同步重试一次(几毫秒),仍失败再投递 MQ。

2、订阅 binlog

由订阅组件(如阿里开源的 Canal、或公司内部的数据总线)解析数据库 binlog,按表和主键删除对应缓存,失败重投。它把缓存维护从业务代码里彻底剥离,也不怕业务进程在删除前崩溃;配合“订阅从库”或“消费端固定延迟”,还能覆盖主从复制延迟。代价是要维护表到缓存 key 的映射,以及订阅链路本身的高可用。

3、事务外发表(Outbox)

在同一个数据库事务里同时写业务表和一张“发件箱表”,由投递器读取发件箱再发往 MQ,消费者删除缓存。它保证“改了库就一定发出消息”,又不依赖 binlog 的读取权限,适合没有数据总线基础设施的团队。Debezium 等工具也提供了基于 binlog 读取发件箱表的组合方案。

消费删除消息时要注意两点:一是幂等,删除本身天然幂等,但如果消费端做的是“带版本的墓碑写入”,要用版本比较防止旧消息覆盖新墓碑;二是有序,同一 key 的消息按 key 分区,避免后发生的删除先被处理、先发生的回填后被处理。

(四)兜底:TTL、校对与可观测

无论链路多可靠,都要给最坏情况留后手:

  • 所有缓存 key 都要有 TTL。TTL 是不一致的“寿命上限”,没有 TTL 的 key 一旦脏了就永远脏。
  • 定期校对。在低峰期扫描关键数据,比对缓存与数据库,删除不一致的条目,并把差异数作为监控指标——差异数突然上升,往往说明删除链路出了问题。
  • 可观测。至少区分三种结果:命中、未命中、缓存调用失败。后两者在命中率上看起来一样,含义却完全不同:未命中多是容量或 TTL 问题,调用失败多是缓存服务本身的问题。

六、五类热门问题:穿透、雪崩、击穿、热点 key、大 key

前两章讲的是“保一致”,这一章回到“挡流量”。缓存挡在数据库前面,一旦某种原因让它挡不住,回源量就会成倍放大。五类问题的成因不同,对策也不同,下面逐一给出实验数据和取舍。

(一)缓存穿透:查一个根本不存在的 key

1、空值缓存与布隆过滤器

请求的数据在数据库里根本不存在,缓存自然也没有,每次都穿过缓存打到数据库,缓存形同虚设。正常业务偶尔也会查不存在的数据,但如果有人恶意用大量不存在的 ID 刷接口,数据库就要承受全部压力。

两种主要手段适用的攻击形态不同。StampedeSim 第三部分用 100 万个真实 ID 和 100 万次攻击请求做了对照,布隆过滤器用的是真实的 Guava BloomFilter:

手段攻击方式打到数据库的请求额外占用
空值缓存(TTL 60 秒)循环使用 1000 个 ID4000 次(0.40%)1000 个空值条目
空值缓存(TTL 60 秒)每次随机新 ID100 万次(100%)100 万个空值条目
布隆过滤器(误判率 1%)每次随机新 ID9919 次(0.99%)1.14MB
布隆过滤器(误判率 0.1%)每次随机新 ID987 次(0.10%)1.71MB

结论很清楚:空值缓存防的是重复,布隆过滤器防的是随机。面对随机 ID,空值缓存不仅挡不住,还会往缓存里塞进 100 万个无用条目,反过来挤占正常数据的空间。布隆过滤器没有漏判(真实 ID 误拒为 0),误判率从 1% 降到 0.1% 只多花 0.57MB。

空值缓存的 TTL 不宜过长,通常几十秒到几分钟:一是空值条目占内存,二是数据如果随后被创建,空值会挡住真实数据,所以新增数据时也要顺手删除对应的空值 key。布隆过滤器的难点在于更新:标准布隆过滤器不支持删除,数据被删后过滤器仍会放行(只是多一次回源,不影响正确性);新增数据必须同步写入过滤器,否则新数据会被误拦——这比放行严重得多,所以新增写入过滤器的链路要和数据库写入一样可靠,并定期全量重建。

2、入口校验与限流

最便宜的防线在最前面:ID 格式、取值范围、签名校验能在网关层拦掉大部分明显非法的请求;对单个调用方、单个 IP 的“查无数据”比例做统计,超过阈值就限流。布隆过滤器和空值缓存是第二道防线,而不是唯一的防线。

(二)缓存雪崩:同一时刻大批 key 一起失效

缓存挡住了大部分流量,一旦缓存大面积失效,流量就会集中涌向数据库,这就是雪崩。它有两种来源:

业务层面:大批 key 同时过期。 典型场景是批量预热或定时任务在同一时刻写入一大批 key,并设置了相同的 TTL。StampedeSim 第二部分模拟了 10 万个 key 在同一时刻预热、TTL 600 秒、每秒 2 万次请求(Zipf 分布)的情况:

过期时间设置回源峰值(次/秒)
固定 600 秒9951(出现在第 600 秒)
600 秒 + 随机 0~60 秒1600
600 秒 + 随机 0~120 秒877
600 秒 + 随机 0~300 秒378

固定 TTL 时,第 600 秒的回源峰值接近每秒请求量的一半;加上 0~120 秒的随机抖动后,峰值降到原来的 9%,总回源量几乎不变——抖动并没有减少回源,只是把它摊平到一段时间里,让数据库扛得住。抖动范围可以按 TTL 的 10%~20% 起步。

系统层面:缓存服务整体不可用。 节点宕机、整个集群故障时,所有请求都会回源。应对它靠的是一套组合:缓存集群自身的多副本与故障切换;本地缓存兜住最热的数据;熔断器在缓存故障时快速失败而不是每个请求都等满超时;数据库侧的限流与降级保证核心请求能被服务。第七章的双缓存方案就是对这一类雪崩的工程化回答。

(三)缓存击穿:一个热 key 过期的那一瞬间

雪崩是“很多 key”,击穿是“一个 key”:某个被高频访问的 key 过期了,那一瞬间所有对它的请求都去查数据库,而这些查询全是重复的——只需要一次结果就能满足所有人。

StampedeSim 第一部分模拟了 20 个应用实例、合计每秒 5000 次请求打同一个 key,key 在第 1 秒过期,回源是一条 80ms 的聚合查询,数据库同时最多跑 16 条:

方案回源次数数据库最长排队p99 延迟返回旧值次数
无保护289273699.2ms0
实例内单飞20450.9ms0
分布式互斥锁(拿不到锁等 50ms 重试)10101.0ms0
逻辑过期(异步刷新)101.0ms433
概率提前刷新101.0ms0

无保护时,289 次重复查询把数据库的 16 个槽位占满,后面排了 273 个,p99 延迟 699ms——这还只是一个 key。几种方案的取舍如下:

  • 实例内单飞:同一实例里同一个 key 只放一个回源请求,其他线程等它的结果。实现简单(一个 ConcurrentHashMap<String, CompletableFuture> 即可,Caffeine 的 LoadingCache 自带这一能力),回源次数降到“实例数”量级。对大多数场景这就够了。
  • 分布式互斥锁:用 SET key token NX PX 3000 抢锁,抢到的回源,其他请求稍等再查缓存。回源只有一次,代价是等待带来的延迟(实验里 p99 约两个重试间隔),以及锁本身的超时与释放问题。
  • 逻辑过期:缓存不设物理过期,值里带一个逻辑过期时间;过期后第一个请求抢锁异步刷新,所有人先拿旧值。延迟最低,代价是刷新完成前返回旧值(实验中 433 次)。适合“晚一点无所谓、但绝不能慢”的数据。
  • 概率提前刷新:在真正过期之前,每个请求以一个随过期临近而增大的概率提前触发刷新。Vattani 等人 2015 年在 VLDB 上给出的 XFetch 算法是这一思路的经典形式:
// XFetch:delta 为一次重算的耗时,beta 默认 1;越接近过期,越可能有人提前刷新
boolean shouldRefreshEarly(long nowMs, long expiryMs, long deltaMs, double beta) {
    double r = ThreadLocalRandom.current().nextDouble();          // (0,1)
    return nowMs - deltaMs * beta * Math.log(r) >= expiryMs;      // -log(r) 为正,相当于把“现在”往后推一段随机时间
}

它的好处是不需要锁、不返回旧值、回源只有一两次;前提是有足够的访问量“碰到”提前刷新的概率,冷 key 用不上它——好在冷 key 本来也不会击穿。

实践中常见的组合是:单飞作为默认,逻辑过期或提前刷新用于极热 key,互斥锁用于“回源代价极高、必须只查一次”的场景。

(四)热点 key:再多的分片也只有一个在扛

1、为什么扩容没用

分布式缓存按 key 路由到分片,同一个 key 永远落在同一个分片上。电商大促、社交热点事件中,单个 key 的访问量可能远超单个分片的能力,表现为三个层次:流量集中到一台机器,物理网卡先达到上限;请求过多,单个分片的处理能力被打垮;分片被打垮后重建,重建过程中流量再次集中过来,再次被打垮,形成恶性循环,引发业务雪崩。

算一笔账:一个 value 为 2KB 的 key,每秒被读 20 万次,就是每秒约 400MB、约 3.2Gbps 的出流量,远超常见的单机网卡余量。这时候给集群加十个分片也没用,因为这个 key 只会在其中一个分片上。

2、治理手段

  • 本地缓存削峰。最有效的一招:50 个应用实例各自把热 key 缓存 1 秒,打到分布式缓存的请求就从每秒 20 万次降到约 50 次,下降 99.97%。代价是最多 1 秒的旧值,这对商品详情、活动配置通常可以接受。
  • 热 key 多副本。把 key 复制成 key#0、key#1、key#2 分散到不同分片,读时随机挑一个,写时(删除时)三个都删。它适合本地缓存放不下或一致性要求更高的情况,代价是写放大与删除的完整性。
  • 读写分离与限流。读请求走从节点分担,对单 key 的访问做限流兜底,宁可部分请求降级也不能让分片被打垮。

3、先发现,才谈得上治理

热 key 的难点往往不在治理,而在“事先不知道谁会热”。常见的发现手段有:客户端埋点采样统计 key 的访问频次;在代理层(如 Twemproxy、自研 Proxy)统计;Redis 4.0 起可以用 redis-cli --hotkeys,但它依赖 LFU 淘汰策略(maxmemory-policy 为 allkeys-lfu 或 volatile-lfu);也有团队用旁路的热点探测服务,实时把热 key 推送给应用,由应用自动开启本地缓存。

(五)大 key:一个 key 堵住整条队

1、为什么危害大

Redis 的命令在一个主线程里逐个执行(Redis 6.0 引入的 I/O 多线程只负责网络读写,命令执行仍是单线程)。一个大 key 带来三类问题:

  • 阻塞:对一个 100 万字段的 Hash 执行 HGETALL、对大集合执行 DEL,时间复杂度是 O(N),执行期间后面所有命令都在排队,表现为整个分片的响应超时。
  • 网络:一次读出几 MB 的数据,占满带宽,客户端反序列化也要很久。
  • 倾斜:大 key 所在的分片内存远高于其他分片,扩缩容迁移时也会卡在它身上。

2、怎么认定与发现

大 key 没有统一标准,下面是一种常见的团队规范(各公司、各云厂商的阈值差别很大,以自己的容量和延迟目标为准):

类型大 key超大 key
Stringvalue 大于 10KBvalue 大于 100KB
Hash / List / Set / ZSet元素超过 1000 个元素超过 1 万个

发现手段:redis-cli --bigkeys 按类型找出元素最多的 key;较新版本 redis-cli 的 --memkeys 按内存占用找;MEMORY USAGE key 查看单个 key 的内存;对 RDB 文件做离线分析,避免在线扫描影响业务。

3、怎么治理

  • 拆:把一个大 Hash 按字段哈希拆成 N 个小 Hash(user:{id}:profile:0..15),读写时先算出字段属于哪个分桶;大 List 按时间或序号分段。
  • 瘦:只缓存真正要用的字段;对大文本压缩;换更紧凑的序列化格式。比如把整份商品对象拆成基础信息、库存、营销信息,按访问路径分别缓存。
  • 删:用 UNLINK(Redis 4.0 起)代替 DEL,在后台线程释放内存;Redis 4.0 起的 lazyfree-lazy-* 系列配置可以让过期、淘汰时也异步释放,Redis 6.0 起还可以用 lazyfree-lazy-user-del 让 DEL 默认异步。集合类也可以用 HSCAN/SSCAN 分批删除。
  • 读:避免 HGETALL、SMEMBERS、LRANGE 0 -1 这类全量读,改为按需读字段或分页。

七、复杂工程方案:本地缓存 + 双缓存主备

前面的手段各自解决一类问题。对于流量很大、而且对缓存高度依赖的平台(比如开放平台网关要在每次调用时查 API 元信息、调用方权限、流控配置),还需要一套把这些手段组织起来的整体方案。下面介绍的“本地缓存 + 双缓存主备”是一种经过实践检验的做法:本地缓存承接数据量小、访问频繁、很少变化的基础数据;两套独立的分布式缓存(例如 Redis 和 Tair)互为主备,任何一套出问题都能切到另一套。

(一)整体分层

整个缓存组件分三层:

  • 接口层:对业务暴露查询、写入、删除和校对任务四类接口。业务只依赖这一层,缓存与数据库对它是透明的——本质上是第三章讲的读写穿透。
  • 策略层:负责降级(配置开关 + 熔断器,支持自动和人工切换)、兜底(定时校对)、报警(监控与告警)。
  • 缓存引擎层:读取模块按策略访问主缓存或备缓存;数据总线订阅数据库变更,负责删除两套缓存;每个应用实例还有一份本地缓存。主缓存和备缓存的角色可以互换。

为什么要两套缓存?分布式缓存集群自身已经有主从、故障切换,但实际运行中仍会出现“单一缓存短时不稳定 → 业务报警”的情况:集群扩容迁移、某个分片主从切换、网络抖动、客户端连接池耗尽。对于把缓存当成“必经之路”的平台,任何一次抖动都会直接变成业务故障。双缓存的价值是降低对单一缓存产品的依赖:两套缓存在不同的集群、甚至不同的产品上,同时出问题的概率要低得多。

(二)策略层:降级、兜底、报警

1、降级

降级是缓存出问题时系统怎么“退”。按严重程度分三档:主缓存熔断或故障时自动切到备缓存;运维发现主缓存性能下降时通过开关人工切换;主备都不可用时直接查数据库。最后这一档最危险——数据库平时只接很少的回源,突然接住全部流量很可能被打垮,所以直查数据库时必须同时开启单飞和数据库连接池限流,宁可让一部分请求失败,也不能让数据库倒下。

熔断器的实现可以直接用 Sentinel、Resilience4j,也可以自己写一个滑动窗口。DualCacheLab 里用的是一个极简版本:最近 20 次调用错误率达到 50% 就打开,2 秒后进入半开状态,每 200ms 放一个探测请求,探测成功就关闭。

2、兜底

兜底是保证缓存与数据库最终一致的手段。一是数据总线:订阅数据库表的变更,及时删除两套缓存中对应的数据,删除失败自动重投;二是定时校对:周期性比对缓存与数据库,修复因更新失败或数据总线异常留下的不一致。

3、报警

报警是让人及时知道。需要持续监控的指标包括:各层命中率、回源 QPS、缓存调用耗时、错误率、熔断次数、校对差异数。任何一项异常——缓存熔断、性能下降、校对发现大量不一致——都要触发通知,交给值班人员处理。

(三)查询流程

1、主备切换与熔断

查询流程的骨架是:本地缓存命中直接返回;否则看缓存是否整体降级,降级则直查数据库;否则优先查主缓存。这里有一个容易写错的细节:主缓存“未命中”和主缓存“异常”要区别对待。未命中说明数据不在缓存里,应该直接回源,而不是再去备缓存查一遍——那样每次未命中都要多一次网络往返。只有主缓存异常、已经熔断或被人工切走时,才去查备缓存。

Row get(String key) {
    Row r = l1.getIfPresent(key);
    if (r != null) return r;                                    // 本地缓存
    if (!switches.cacheDegraded) {
        boolean usePrimary = !switches.manualBackup && primaryBreaker.allow();
        boolean primaryFailed = false;
        if (usePrimary) {
            try { r = primary.get(key); primaryBreaker.record(true); }
            catch (CacheError e) { primaryBreaker.record(false); primaryFailed = true; }
            if (r != null) { l1.put(key, r); return r; }
        }
        // 主缓存“未命中”直接回源;只有异常、熔断或人工切换时才查备缓存
        if (!switches.backupOff && (!usePrimary || primaryFailed) && backupBreaker.allow()) {
            try { r = backup.get(key); backupBreaker.record(true); }
            catch (CacheError e) { backupBreaker.record(false); }
            if (r != null) { l1.put(key, r); return r; }
        }
    }
    r = loadOnce(key);          // 同 key 单飞回源(数据库连接池自带等待上限)
    l1.put(key, r);
    asyncFill(key, r);          // 异步回填主、备缓存,各自检查降级开关;失败不影响本次返回
    return r;
}

这段代码摘自 DualCacheLab,回源后的回填是异步、不要求成功的:即使缓存不稳定、回填失败,本次请求也已经拿到了数据,后续请求会再次尝试。回填用的是带版本比较的写入(setIfNewer),旧版本不会覆盖新版本,这一点在下一节的一致性实验里会看到它的作用。

2、故障演练:熔断器决定了“慢故障”有多疼

DualCacheLab 实验一用 4 个应用实例、每个 4 个读线程,对同一套负载依次注入五个阶段(每阶段 3 秒),并在“有熔断”和“无熔断”两种配置下各跑一遍:

阶段有熔断 QPS有熔断 p99无熔断 QPS无熔断 p99
正常198820.3ms185870.3ms
主缓存变慢(每次超时 30ms)191860.3ms95540.7ms
主缓存恢复199540.3ms176700.8ms
主备全挂(快速失败)100873.0ms87474.0ms
全部恢复161803.0ms173180.9ms

三个现象值得记住:

  • 慢比挂更可怕。主缓存变慢时,没有熔断的配置每个未命中本地缓存的请求都要等满 30ms 超时,吞吐跌到正常的二十分之一;有熔断的配置每个实例只付出了一次熔断(共 4 次),之后流量全部走备缓存,吞吐几乎不受影响。“连接被拒绝”这类快速失败反而没那么疼——主备全挂阶段两种配置的 p99 都只有几毫秒。
  • 主备全挂时,单飞和连接池限流守住了数据库。回源约每秒 3200 次(有熔断 3245、无熔断 3034),吞吐减半但没有一个报错。如果没有单飞,同一个 key 的并发回源会成倍放大。
  • 熔断恢复有代价。缓存恢复后,熔断器还要在打开状态里待满 2 秒才放探测,这段时间请求仍然走数据库(“全部恢复”阶段有熔断配置的回源约每秒 1081 次、p99 3.0ms)。打开时长要在“避免反复试探故障节点”和“恢复后尽快回暖”之间取平衡,生产上通常配合半开探测与逐步放量。

3、异步加载不强求成功

查询流程里的“回源后异步写入缓存”有意设计成不要求即时成功:缓存不稳定时回填失败,不影响本次返回,后续请求会重试,最终由数据总线和校对任务兜住。这样即使缓存出问题、甚至部分数据暂时缺失,服务也能继续,而不会因为缓存问题导致整体中断。

(四)更新流程

1、数据总线驱动删除

更新流程由数据总线驱动:数据库变更后,数据总线收到消息,先看缓存开关是否打开、这次变更是否影响缓存,然后分两路删除主缓存和备缓存(备缓存先判断是否可用)。两路都成功才算完成;任何一路失败,都标记本次更新失败,退避后重投(实验中是 50ms、100ms……最多 800ms)。

注意这里做的是“删除”而不是“更新”,与第三章的旁路缓存一致;数据总线订阅的是 binlog,本身就是第五章“删除必达”的第二条链路。

2、部分成功的风险

有一种直觉做法是:主备两路只要有一路删除成功,就认为更新成功,因为“当前提供服务的那一套是对的”。问题在于主备随时可能切换——备缓存里留下的旧值,平时没人读,一旦主缓存出故障、流量切到备缓存,旧值就会集中暴露出来。所以部分成功必须被当作失败来处理:标记失败、触发重试,直到两路都成功。

3、实验:重试和校对各管一段

DualCacheLab 实验二让写入以每秒约 400 次均匀落在 2 万个 key 上,期间备缓存出现 2 秒的删除超时(失败率 20%),数据总线还停摆 1 秒。三种配置下,写入结束、数据总线清空后的结果:

配置收尾时备缓存脏条目校对修复校对后脏条目切到备缓存后,被改过的 key 读到旧值
不重试46未开启464.30%
数据总线重试(重试 70 次)0—00%
不重试 + 校对任务303000%

主缓存在三种配置下都没有残留——数据总线停摆只是把删除推迟了,恢复后会补上。值得注意的是“不重试”时只留下了 46 个脏条目,而不是失败的上百次删除:被频繁读到的热 key 会在回源后以“带版本的回填”把备缓存覆盖成新值,自己愈合了;真正留下脏数据的,是很少被读到的冷 key。它们平时不出声,等到切换时才暴露,这正是校对任务存在的意义。

4、低峰期校对

校对任务(图中由老掌柜负责)在每天的低峰期自动运行:查询数据库,分别取两套缓存的数据与之比对,删除不一致的条目,完成后发送通知告知执行情况和差异数;也支持在紧急情况下手动触发,或通过开关随时停止。全量校对对数据库有压力,数据量大时可以只校对最近变更过的 key(从 binlog 或更新时间索引取),或者分批限速执行。

(五)本地缓存的失效广播

数据总线删除分布式缓存之后,还要通知所有应用实例让本地缓存失效,常用的通道是 Redis Pub/Sub、MQ 广播或配置中心推送。广播是“尽力而为”的,会丢。实验三只改最热的 200 个 key(每秒约 250 次写),本地缓存写后 3 秒过期,对比不同的广播丢失率:

广播丢失率写入期间读到旧值的比例停写后旧条目数(0 / 1 / 2 / 3 / 3.5 秒)
0%0.031%0 / 0 / 0 / 0 / 0
1%0.130%3 / 2 / 1 / 0 / 0
5%1.864%23 / 19 / 4 / 0 / 0

即使丢失率 0%,读到旧值的比例也不是零——广播从发出到生效有时间差。而无论丢失多少,3 秒后旧条目都清零了:本地缓存的 TTL 就是旧值寿命的上限,广播负责“快”,TTL 负责“兜底”。这也是为什么本地缓存的 TTL 应该按业务能容忍的最长旧值时间来定,而不是越长越好。更进一步,Redis 6.0 起提供客户端缓存(Client-side caching)协议,由服务端追踪客户端读过的 key 并在变更时推送失效消息,Lettuce、Jedis 等客户端已提供支持,可以替代自建的广播通道。

(六)这套方案的代价与适用边界

双缓存不是免费的:

  • 成本翻倍:两套缓存集群的内存与机器,以及两套运维体系。
  • 写放大:每次变更要删两套缓存,数据总线的处理量和失败面都翻倍。
  • 复杂度:熔断、开关、校对、两套客户端的适配,每一项都要测试、演练。
  • 一致性并没有变强:它解决的是可用性,一致性仍然依赖删除必达与校对。

所以它适合的是:流量大、几乎所有请求都要经过缓存、缓存抖动会直接造成业务故障的平台型系统(网关、开放平台、配置中心、商品基础信息)。对于普通业务系统,一套高可用的分布式缓存 + 本地缓存 + 熔断降级到数据库,通常已经足够。

八、落地清单与结论

(一)上线前检查清单

把前面七章压缩成十个问题,答完了再让缓存接流量:

  1. 这份数据允许多旧?把答案写进 TTL 与更新策略。
  2. 更新顺序是不是“先提交数据库,再删除缓存”,删除是否放在事务提交之后?
  3. 删除失败怎么办?业务内重试、订阅 binlog、事务外发表至少选一种。
  4. 读的是从库吗?延迟删除是否覆盖了复制延迟的高分位,或者改用版本化回填?
  5. 不存在的 key 会不会打到数据库?空值缓存防重复,布隆过滤器防随机。
  6. 过期时间有没有加随机抖动?
  7. 热 key 有没有单飞、逻辑过期或提前刷新?是否用本地缓存削峰?
  8. 有没有在上线前扫描大 key?超过阈值的是否已经拆分?
  9. 熔断、降级开关、数据库限流有没有演练过?
  10. 命中率、回源 QPS、调用耗时、错误率、校对差异数是否都有监控和告警?

(二)结论与适用范围

回到开头的两件事:

挡流量靠的是层层削峰与故障时的有序退让。本地缓存挡住最热的那一小撮 key(实验中不到一成的 key 挡住了七成流量),分布式缓存挡住剩下的大部分;穿透用布隆过滤器和空值缓存,雪崩用 TTL 抖动和多副本,击穿用单飞、逻辑过期或提前刷新,热点 key 用本地缓存和多副本,大 key 用拆分与异步删除;缓存本身出故障时,熔断器让“慢故障”变成“快切换”,单飞和连接池限流守住数据库。

保一致靠的是“缩小窗口 + 必有兜底”。先更新库再删缓存是正确的起点,但它的“概率很小”只在读主库、写入不频繁、没有长停顿时成立;一旦读从库,脏数据几乎是必然的。延迟双删能把概率压低,binlog 订阅保证删除必达,版本墓碑能从根上拒绝旧值回填,定期校对修复冷 key 上的残留,TTL 给所有不一致设定寿命上限。

适用范围也需要说清楚:本文的方法适用于读多写少、能容忍秒级到分钟级旧值的业务数据;余额扣减、库存锁定这类“读到旧值就会出错”的操作,不应依赖缓存做判断,应直接读权威数据源。文中的实验数字来自仿真与单机多线程实验,用于说明趋势和量级,具体阈值(TTL、抖动范围、双删间隔、熔断参数)要结合自己系统的复制延迟、GC 情况和流量分布来定。

参考链接

同系列文章

论文与工程实践

工具与文档

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/xiaofeng10330111/article/details/140759153

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--