缓存没坏,你的服务却挂了
先说个扎心的事实:缓存是后端系统里最大的谎言之一。它让你以为查询很便宜,它让流量高峰变得平滑,它让你的监控图漂亮得像个梦。然后某天某个冷门商品的 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 就完事」,它是一整套关于过期、竞态、失效、降级的工程设计。
我见过太多系统,上线时把缓存当银弹,出事时把缓存当罪魁祸首。真正成熟的做法是:承认缓存永远可能不一致、永远可能被打穿,然后为这些情况准备好降级路径。
说到底,缓存不是用来「假装数据库很快」的,它是用来保护数据库别被打死的。目标想清楚了,很多纠结自然就消失了。
缓存会过期、会失效、会被淘汰;但你的系统不该跟着一起崩。