缓存雪崩、击穿、穿透:别再混着讲,三兄弟得用三套连招

2026-11-20 14 0

缓存雪崩、击穿、穿透:三兄弟长得像,打法完全不同

每次面试都有人问我这三个词的区别。我每次都想画个图,但发现画出来更让人困惑——因为它们本质上是三种完全不同的失败模式,只是都表现为"缓存没生效"。今天不谈概念定义,直接上战场。


一、缓存穿透:请求的钥匙根本不存在

场景:一个不存在的商品 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 顺序消费 延迟双删(承认不完美)

最后一条经验:这四个问题里,前三个是流量问题,第四个是共识问题。前三个靠工程手段能解决八九成,第四个没有银弹——你只是在不同的"数据可能短暂不一致"之间做选择。选一个自己业务能承受的,然后写进设计文档,别让它变成一个没人记得的历史遗留问题。

缓存的复杂度从来不在写代码那五分钟,而在你想清楚"什么情况下可以返回旧数据"的那一刻。

相关文章

你的服务器没崩、没满、没报错,但请求就是超时:conntrack 表打满,这个被集体冤枉的凶手
扩个节点抖三抖:Redis Cluster 槽迁移、MOVED/ASK 与大 key 的连环坑
你的 WebSocket 三分钟就断:心跳、重连与一百万连接的真相
42 KB 的请求,打爆 126 MB 的内存:gzip 解压炸弹,你的接口正裸奔
缓存没坏,你的服务却挂了:穿透、击穿、雪崩,以及那份永远对不上的数据
你的写入明明很快,直到磁盘开始抖:LSM-Tree 的三把刀,和一次 RocksDB 磁盘风暴复盘

发布评论