学完这篇,你能在 Go 服务里搭出一套「本地缓存 + Redis + MySQL」的多级缓存,并知道写操作时怎么删缓存、本地缓存怎么跨实例失效、哪些情况注定有一致性窗口。
第一步:先想清楚要哪种一致性
多级缓存的一致性不是「绝对一致」,而是「最终一致 + 可接受的不一致窗口」。你要先定两件事:
- 允许多久不一致:业务能忍 100ms 还是 5s?这决定你选广播失效还是纯 TTL 兜底。
- 谁是权威数据源:永远是 MySQL,缓存只做副本,任何冲突以库为准。
分层结构通常是:L1 本地缓存(进程内,ns 级)→ L2 Redis(ms 级)→ L3 MySQL。L1 靠 TTL + 主动失效,L2 靠写操作删除。
第二步:读路径怎么走
标准读流程:查 L1 → 命中返回;未命中查 Redis → 命中回填 L1 返回;再未命中查 DB,回填 Redis 和 L1。
func (s *Svc) Get(ctx context.Context, id int64) (*Item, error) {
key := fmt.Sprintf("item:%d", id)
if v, ok := s.local.Get(key); ok { // L1
return v.(*Item), nil
}
var item Item
if err := s.redis.Get(ctx, key, &item); err == nil { // L2
s.local.Set(key, &item, 30*time.Second) // L1 TTL 要比 L2 短
return &item, nil
}
// 回源 DB
item, err := s.db.FindItem(ctx, id)
if err != nil { return nil, err }
s.redis.Set(ctx, key, item, 10*time.Minute)
s.local.Set(key, item, 30*time.Second)
return item, nil
}
注意:L1 的 TTL 必须明显短于 L2 的 TTL。L1 越短,广播丢消息时不一致窗口越小。常见配比是 L1 30 秒、L2 10 分钟。
第三步:写路径——更新库 + 删缓存
不要「更新缓存」,要「删除缓存」。更新缓存会在并发写时出现旧值覆盖新值:两个写请求 A、B,A 先写库、B 后写库,但 B 先更新缓存、A 后更新缓存,缓存里就留下 A 的旧值。删除操作是幂等的,没有这个顺序问题。
顺序是「先写库,再删缓存」,不要反过来(先删缓存再写库,中间有读请求会把旧值回填进缓存,而且存活很久)。
func (s *Svc) Update(ctx context.Context, item *Item) error {
if err := s.db.UpdateItem(ctx, item); err != nil {
return err
}
key := fmt.Sprintf("item:%d", item.ID)
s.redis.Del(ctx, key) // 删 L2
s.broadcastInvalidate(ctx, key) // 通知各实例删 L1
return nil
}
如果更新逻辑涉及多表或事务、耗时较长,再加一次「延迟双删」:写库前删一次、写库后延迟 500ms 再删一次,专门清掉在「写库完成到删缓存」之间被回填的旧值。
注意:延迟双删的延迟时间不好估,只能缓解不能根治。真正可靠的方案是订阅 MySQL binlog(canal / go-mysql)来触发删缓存,把「删缓存」从业务代码里解耦。
第四步:本地缓存怎么跨实例失效
L1 在进程内,A 机器改了数据,B 机器的 L1 还是脏的。解决办法是广播:用 Redis 的 Pub/Sub 或消息队列发一条失效消息,所有实例收到后删掉自己本地对应的 key。
func (s *Svc) broadcastInvalidate(ctx context.Context, key string) {
s.redis.Publish(ctx, "cache:invalidate", key)
}
// 每个实例启动时订阅
func (s *Svc) subscribe() {
sub := s.redis.Subscribe(context.Background(), "cache:invalidate")
for msg := range sub.Channel() {
s.local.Delete(msg.Payload)
}
}
注意:Redis Pub/Sub 是「发后不管」,不保证投递——订阅端断线重连的那几百毫秒内的消息会丢。所以 L1 的 TTL 不能省,它是最后一道防线。要更可靠就把频道换成 Redis Stream 或 Kafka,并记录消费位点。
第五步:补两个兜底
空值缓存与击穿保护:DB 查不到时也往 Redis 写一个短 TTL 的空标记(比如 60 秒),避免同一 key 反复打库。同时用 singleflight 把同一 key 的并发回源合并成一次:
v, err, _ := s.group.Do(key, func() (interface{}, error) {
return s.loadFromDB(ctx, key) // 只有一个人真正查库
})
版本号校验:给数据表加 version 或 updated_at 字段,缓存里一起存。写操作时 version 自增。读 L1 命中后如果业务对一致性要求高,可以异步比对一次 Redis 里的 version,不一致就淘汰 L1。这个方案成本高,只在对一致性敏感的核心数据上用。
注意:别在循环里逐 key 发失效消息,改成批量频道或一次发一个 key 列表,否则写放大严重。
小结
- 数据源永远是 DB,缓存只做副本,目标是最终一致,不是强一致。
- 读:L1 → L2 → DB,逐层回填;L1 TTL 必须短于 L2 TTL。
- 写:先更 DB,再删缓存;删而不是更新;必要时延迟双删。
- L1 跨实例靠 Redis Pub/Sub 广播失效,但它是不可靠投递,TTL 是兜底。
- 治本方案是订阅 binlog 触发失效,把缓存逻辑从业务代码里剥离。
- 空值缓存 + singleflight 防击穿,版本号只用在少数核心数据上。