缓存没坏,你的服务却挂了:穿透、击穿、雪崩,以及那份永远对不上的数据

2026-11-19 5 0

缓存没坏,你的服务却挂了

先说个扎心的事实:缓存是后端系统里最大的谎言之一。它让你以为查询很便宜,它让流量高峰变得平滑,它让你的监控图漂亮得像个梦。然后某天某个冷门商品的 id 被人爬了一遍,数据库直接躺平——缓存明明一个字节都没坏。

这篇咱们把这层窗户纸捅开:讲透穿透、击穿、雪崩这老三样,以及那个每个后端工程师都栽过跟头的缓存与数据库双写一致性。


一、穿透:查询不存在的东西

先看最简单的一种。攻击者或者好奇的用户,疯狂请求 /api/product/999999999,这个 id 根本不存在。

你的代码逻辑很正确:

product = redis.get("product:999999999")
if product is None:
    product = db.query("select * from products where id = ?", id)
    if product is None:
        return 404
    redis.set("product:" + id, product)
return product

问题在哪?不存在的东西,你没缓存。每一次请求都穿透到数据库,缓存命中率看起来很高(因为查得多的都有缓存),但数据库收到了成倍流量。这就是缓存穿透。

最蠢的解法是缓存空值:

if product is None:
    product = db.query(...)
    if product is None:
        redis.set("product:null:" + id, "nil", ex=60)
        return 404

能用,但丑。更体面的做法是布隆过滤器:启动时把所有合法 id 灌进位图,请求进来先问它「这个 id 可能存在吗」,说不可能就直接 404,连 Redis 都不碰。

代价是布隆过滤器只能加不能删(要删只能重建),以及假阳性——但假阳性只意味着「多查一次数据库」,不影响正确性。这个 trade-off 我觉得相当划算。


二、击穿:某个热点 key 过期了

比穿透更致命的一种。因为它是正常流量触发的。

想象一个爆款商品,缓存 TTL 1 小时。它的 key 在同一秒过期,涌进来的上千个请求同时发现缓存空了,于是同时去查数据库、同时去写缓存。数据库被这一波查询打成峰值,缓存写入又因为「先写的先覆盖」而反复挣扎。

更阴险的版本:缓存重建时数据库本身很慢。查库要 2 秒,这 2 秒内所有请求都在等——叫「缓存击穿」,但你的 QPS 其实一点没涨,只是全堵在同一个 key 上。

解法有两个层次:

互斥重建(single-flight):只有第一个没命中的请求去查库,其他人等它完成后直接从缓存拿。Go 里用 golang.org/x/sync/singleflight,Java 里用 Caffeine 的 loadingCache 语义,Redis 侧则是 SETNX 锁。

// Go: singleflight 简版思路
v, err, _ := group.Do("product:"+id, func() (any, error) {
    // 同一时刻只有一个 goroutine 真的进来查库
    p := queryDB(id)
    redis.Set("product:"+id, p, 1*time.Hour)
    return p, nil
})

逻辑过期 + 异步刷新:缓存里存的值带一个过期时间戳,但真正的 TTL 设得很长(比如 10 分钟)。读到过期值时,先返回旧数据,同时起个后台任务去更新。用户永远不卡,只有极端情况下会读到几秒钟的旧数据。

这个思路的本质是:可用性 > 新鲜度。大多数业务场景下,用户看到 3 秒前的价格,比看到 3 秒的超时,要友好得多。


三、雪崩:缓存集体过期

如果给每个 key 的 TTL 都写死成 1 小时,那么每小时整点就有大批 key 同时失效,流量在那一刻全部砸向数据库——像雪崩一样。

更糟的情况是:缓存节点挂了。这时所有请求同时失去缓存,数据库承受 100% 的读流量,而它本来只该承受 10%。

对策有三板斧:

  • TTL 加随机抖动:ex = base + random(0, 300)。把集体失效打散成随机分布,一行代码的改动,收益立竿见影。
  • 多级缓存:本地 Caffeine 挡一层,Redis 挡一层。Redis 挂时,本地缓存还能撑一阵子。
  • 熔断降级:数据库压力超阈值时,快速失败并返回兜底数据,别让请求把数据库彻底压死。宁可报错,也别雪崩。

缓存系统的第一性原理:缓存挂了,系统应该变慢,而不是崩溃。任何没做过降级设计的缓存方案,都是在给未来埋雷。


四、双写一致性:那个永远对不上的数据

前三个问题相对独立,这一块才是真正的修罗场。

经典写法是 Cache-Aside:读的时候先查缓存再查库,写的时候先更新数据库,再删除缓存。

// 写
db.update(...)
redis.del("key:" + id)

// 读
v = redis.get("key")
if v is None:
    v = db.query(...)
    redis.set("key", v)

为什么是「先库后删缓存」而不是「先删缓存后写库」?因为后者的窗口期里,并发读会把数据库里的旧值重新写回缓存,等你的数据库写入完成后,缓存里躺着一个永久过期的旧值——直到下一次 TTL 到期。

但「先库后删」也不是完美的,存在两个经典竞态:

竞态 A(删缓存前,并发读写了旧值):

T1: 写库 -> 新值
T2: 读缓存 miss -> 查库 -> 得到旧值(此时 T1 还没提交)
T3: T2 写回缓存 -> 缓存是旧值
T4: T1 删除缓存 -> OK,缓存已清

结果是 T4 把脏数据清掉了,最终一致。但顺序反了呢?T1 删缓存、T2 才写回旧值,那么这个旧值会在缓存里待满一个 TTL。这就是为什么大家都强调「删除要放在数据库写入之后」。

竞态 B(删除失败):数据库写成功了,redis.del 因为网络抖动失败了怎么办?缓存里就是旧数据,而且没人会再删它——直到 TTL 到期。

工程上的解法是延迟双删:删一次,等 500ms(按延迟量级调),再删一次。第二次删除专门用来兜住「第一次删除之后、并发读写回旧值」这个窗口。

但延迟双删也不够优雅。真正稳的做法是订阅 binlog:用 Canal / Debezium 监听 MySQL binlog,把变更事件投递到消息队列,再由消费者删缓存。这样:

  • 缓存删除不依赖应用层的 redis 客户端,连接抖动不再影响一致性;
  • 失败可以重试,MQ 本身就带持久化;
  • 多个服务更新同一份数据时,不需要各自写删除逻辑。

代价当然也有:链路多了一个环节(MySQL → binlog → MQ → 消费者 → Redis),延迟从毫秒级变成几十甚至上百毫秒,还要处理重复消费和乱序。

没有银弹。延迟双删是「简单但有缝」,binlog 订阅是「可靠但复杂」。选哪个取决于你的数据不一致能容忍多久——能容忍 5 分钟就别上 MQ,扛不住就别省那个 MQ。


五、别忘了你的缓存有「第二套过期时间」

一个容易被忽略的细节:Redis 的 TTL 和客户端本地缓存的 TTL 是两套东西。

如果你的服务在本地又做了一层 Caffeine 缓存,TTL 配了 10 分钟,而 Redis 里的 TTL 是 1 小时——那么当 Redis 数据被更新并删除后,本地那份旧数据还要再赖 9 分钟。

还有一种更隐蔽的:Redis 的内存淘汰策略。当内存达到上限,Redis 会按 LRU/LFU 策略悄悄淘汰 key——没有通知、没有日志(除非你配了 notify-keyspace-events)。你的业务代码毫不知情,只觉得「怎么突然全打到数据库了」。

排查这类问题时,建议打开:

CONFIG SET notify-keyspace-events "Ex"

订阅 __keyevent@0__:expired 和 __:evicted 频道,至少能知道到底是「过期了」还是「被淘汰了」——这两种问题的解法完全不同。


六、一份可以直接抄的检查清单

  • 缓存空值 / 布隆过滤器,防穿透
  • singleflight 或逻辑过期,防击穿
  • TTL 随机抖动 + 多级缓存 + 熔断降级,防雪崩
  • 先写库再删缓存,删除失败要有重试或 binlog 兜底
  • 本地缓存 TTL 必须短于远端 TTL,或者干脆不设本地缓存
  • 监控命中率、淘汰数、回源 QPS,而不是只监控「服务有没有挂」

结语

缓存优化不是「加个 Redis 就完事」,它是一整套关于过期、竞态、失效、降级的工程设计。

我见过太多系统,上线时把缓存当银弹,出事时把缓存当罪魁祸首。真正成熟的做法是:承认缓存永远可能不一致、永远可能被打穿,然后为这些情况准备好降级路径。

说到底,缓存不是用来「假装数据库很快」的,它是用来保护数据库别被打死的。目标想清楚了,很多纠结自然就消失了。

缓存会过期、会失效、会被淘汰;但你的系统不该跟着一起崩。

相关文章

42 KB 的请求,打爆 126 MB 的内存:gzip 解压炸弹,你的接口正裸奔
你的写入明明很快,直到磁盘开始抖:LSM-Tree 的三把刀,和一次 RocksDB 磁盘风暴复盘
一个连接扛住十倍并发,然后被自己的 64KB 掐死了:HTTP/2 流控窗口的真相
你的 Node 服务只有一个线程,却扛住了十万并发:事件循环的真相,和它翻车的三种姿势
你的搜索为什么慢得像在刨坟:Elasticsearch 倒排索引的一次翻车现场
你加了一个字段,生产环境炸了:论 API 兼容性的真正战场

发布评论