缓存雪崩、击穿、穿透:三兄弟长得像,打法完全不同
每次面试都有人问我这三个词的区别。我每次都想画个图,但发现画出来更让人困惑——因为它们本质上是三种完全不同的失败模式,只是都表现为"缓存没生效"。今天不谈概念定义,直接上战场。
一、缓存穿透:请求的钥匙根本不存在
场景:一个不存在的商品 ID,product:999999 在 Redis 里永远查不到,于是每次请求都穿透到 MySQL,然后 MySQL 也查不到,然后……数据库被打爆了。
最蠢的解法是缓存空值:查不到就写一个空标记进去,设个短 TTL。代码如下:
func GetProduct(ctx context.Context, id int64) (*Product, error) {
key := fmt.Sprintf("product:%d", id)
raw, err := rdb.Get(ctx, key).Bytes()
if err == nil {
if len(raw) == 0 {
return nil, ErrNotFound // 空值标记
}
return decode(raw), nil
}
if err != redis.Nil {
return nil, err
}
// 回源
p, err := repo.FindByID(ctx, id)
if err != nil {
return nil, err
}
if p == nil {
rdb.Set(ctx, key, "", 5*time.Minute) // 空值短 TTL
return nil, ErrNotFound
}
rdb.Set(ctx, key, encode(p), 30*time.Minute)
return p, nil
}
这招有效,但它治的是"不存在的值"这一类。真正的恶意流量扫的是随机的、根本不存在的键,空值缓存挡不住——因为每个随机 ID 都是新的空值,照样打 DB。
这时候得上布隆过滤器(Bloom Filter)。
// 初始化:把所有可能存在的 key 灌进去
func BuildBloomFilter(ctx context.Context) error {
ids, err := repo.AllProductIDs(ctx) // 全量 ID
if err != nil { return err }
bf := bloom.NewWithEstimates(uint64(len(ids)*10), 0.01)
for _, id := range ids {
bf.Add([]byte(fmt.Sprintf("product:%d", id)))
}
return bf.SaveToFile(bloomPath)
}
// 请求前置检查
func GetProduct(ctx context.Context, id int64) (*Product, error) {
key := fmt.Sprintf("product:%d", id)
if !bf.Test([]byte(key)) {
return nil, ErrNotFound // 一定不存在,直接返回,不碰 DB
}
// ... 正常缓存逻辑
}
布隆过滤器的特性必须记牢:不会误判存在,但会误判不存在。也就是说,误判率 1% 意味着有 1% 的真实请求被挡在门外。所以误判率别设太小,0.01~0.001 之间通常够用,省下的 DB 压力远大于那点漏掉的请求。
额外提醒:布隆过滤器要定期重建。ID 集合变了但过滤器没更新,新建的商品会被直接判不存在——这种 bug 排查起来能让人怀疑人生。
二、缓存击穿:某个热点 key 突然过期
这是最经典的翻车现场:某个商品被全网请求,突然它的缓存 TTL 到了,几千个并发请求在同一瞬间发现缓存没了,同时去查数据库、同时去重建缓存。
解决思路有三条,从简单到讲究:
第一层:互斥锁(singleflight)。 只让一个请求去回源,其他请求等着拿结果。
var g singleflight.Group
func GetProduct(ctx context.Context, id int64) (*Product, error) {
key := fmt.Sprintf("product:%d", id)
raw, err := rdb.Get(ctx, key).Bytes()
if err == nil {
return decode(raw), nil
}
// 同一个 key 的并发请求会被合并成一个
v, err, _ := g.Do(key, func() (interface{}, error) {
// 双重检查:等锁期间可能已经被别人填好了
if raw, e := rdb.Get(ctx, key).Bytes(); e == nil {
return decode(raw), nil
}
p, err := repo.FindByID(ctx, id)
if err != nil { return nil, err }
rdb.Set(ctx, key, encode(p), 30*time.Minute)
return p, nil
})
if err != nil { return nil, err }
return v.(*Product), nil
}
Go 官方 golang.org/x/sync/singleflight 就是干这个的,Java 里对应 Guava 的 CacheLoader 或 Redisson 的分布式锁。注意:singleflight 只在单进程内生效,多实例部署还得靠 Redis 分布式锁或者更简单的方案。
第二层:逻辑过期(不设 TTL,改存过期时间戳)。 缓存永不失效,但数据里带一个 expireAt 字段。读到过期数据时,先返回旧数据,再异步去更新。
type CacheEntry struct {
Data []byte `json:"data"`
ExpireAt int64 `json:"expire_at"`
}
func GetProduct(ctx context.Context, id int64) (*Product, error) {
key := fmt.Sprintf("product:%d", id)
raw, err := rdb.Get(ctx, key).Bytes()
if err != nil {
return rebuild(ctx, id)
}
var e CacheEntry
json.Unmarshal(raw, &e)
if time.Now().Unix() > e.ExpireAt {
// 过期了,但先返回旧数据,同时异步刷新
go refreshAsync(id)
}
return decode(e.Data), nil
}
这个方案的精髓是牺牲数据新鲜度换取可用性。用户永远拿得到东西,至多旧了几十秒。对商品详情、排行榜这种场景非常合适;对余额、库存这种强一致的就别碰了。
第三层:热点探测 + 提前预热。 用订阅 Redis 的 keyspace 通知,或者用定时任务扫访问频次 Top N 的 key,在它们过期前就刷新掉。听起来复杂,但对电商大促这种场景是必须上的。
三、缓存雪崩:大批 key 同时失效
雪崩和击穿的区别在于规模:不是一个 key 过期,而是成千上万个 key 在同一时刻集体过期,或者 Redis 集群直接挂了。
典型的雪崩成因有三个:
- TTL 相同:批量预热时所有 key 都设了 30 分钟,于是半小时后集体到期,流量瞬间全部回源。
- Redis 宕机:缓存层整体不可用,所有流量直穿数据库。
- 大促流量:平时 QPS 100 的服务,大促 QPS 10000,缓存命中率再高也扛不住那多出来的 9900。
解法组合拳:
// 1. TTL 加随机抖动,消灭 TTL 相同问题
func ttlWithJitter(base time.Duration) time.Duration {
return base + time.Duration(rand.Int63n(int64(base/10)))
}
// 2. 本地缓存兜底(即使 Redis 挂了还有一层)
var localCache = ristretto.NewCache(&ristretto.Config{
NumCounters: 1e6, MaxCost: 1<<28, BufferItems: 64,
})
// 配合 singleflight 防止本地缓存击穿
// 3. 熔断降级:回源失败率超阈值时,直接返回兜底数据
// 保护数据库优先于保证准确
第二层本地缓存还有个隐藏好处:把回源的 QPS 削平。没有本地缓存时 1 万 QPS 直接砸向 DB;有本地缓存后,真正到 DB 的可能只有几百 QPS。
很多人熔断只做了"熔断 Redis",忘了熔断数据库。真正的保护对象永远是数据存储——它是最后一层,不能倒。
四、说点更扎心的:缓存一致性问题
上面三个问题解决的是"缓存没有",但更折磨人的是"缓存有,但是旧的"。经典场景:
// 读
v := getFromCache() // 旧值
if v == nil { v = getFromDB() }
// 更新
db.Update(...)
cache.Delete(key) // 删除缓存
这段代码看着没问题,直到并发发生:读线程刚拿到旧值还没返回,写线程更新了 DB 并删了缓存,然后读线程把旧值又写回缓存。之后这个 key 脏到过期为止。
常见的改法是"延迟双删":
func UpdateProduct(ctx context.Context, p *Product) error {
if err := repo.Update(ctx, p); err != nil { return err }
rdb.Del(ctx, key(p.ID))
time.Sleep(500 * time.Millisecond) // 等读线程的旧值回写
rdb.Del(ctx, key(p.ID))
return nil
}
能解决大部分情况,但那个 Sleep 让人心里不踏实,延迟多少全靠拍脑袋。更工程化的选择:
- 订阅 binlog(Canal / Debezium / Flink CDC):以数据库的变更日志为唯一真相源,缓存失效动作由日志驱动,不依赖应用层的代码正确性。链路长,但一致性最扎实。
- 消息队列串行化:同一 key 的更新消息投递到固定分区,保证顺序消费。写路径和缓存失效都在消费者里做。
- 放弃强一致:明确产品需求就是"允许秒级延迟",然后大方承认,别假装自己在做分布式事务。
说实话,很多团队在"读多写少"的场景里直接选第三条——因为它最便宜,也最诚实。强一致是要付钱的,付钱之前先算算账。
五、一张表收尾
| 问题 | 触发条件 | 首选方案 | 兜底方案 |
|---|---|---|---|
| 穿透 | 查不存在的 key | 布隆过滤器 | 空值缓存 + 参数校验 |
| 击穿 | 热点 key 过期 | singleflight / 互斥锁 | 逻辑过期 + 异步刷新 |
| 雪崩 | 批量失效 / 缓存宕机 | TTL 抖动 + 本地缓存 | 熔断降级 + 预案 |
| 不一致 | 并发读写 | binlog 订阅 / MQ 顺序消费 | 延迟双删(承认不完美) |
最后一条经验:这四个问题里,前三个是流量问题,第四个是共识问题。前三个靠工程手段能解决八九成,第四个没有银弹——你只是在不同的"数据可能短暂不一致"之间做选择。选一个自己业务能承受的,然后写进设计文档,别让它变成一个没人记得的历史遗留问题。
缓存的复杂度从来不在写代码那五分钟,而在你想清楚"什么情况下可以返回旧数据"的那一刻。