CClara轻量论坛系统

Go 语言缓存一致性:本地缓存与 Redis 双写策略

laoxie
laoxie 正式会员正式会员认证极客认证极客
发布于 2026-11-16 16:46 ·13 浏览 ·5 回复
内容摘要

在 Go 服务中搭建本地缓存、Redis 与 MySQL 多级缓存的方案以实现最终一致并控制不一致窗口,读路径按 L1、L2、数据库逐级回源回填且 L1 TTL 应短于 L2,写路径应先更新数据库再删除 Redis 缓存并广播失效各实例本地缓存,事务耗时场景可辅以延迟双删,但只能缓解无法根治一致性问题。

学完这篇,你能在 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 防击穿,版本号只用在少数核心数据上。
本文转载自 Clara轻量论坛系统,原文地址:https://www.leleweb.cn/thread-1183.html
转载请注明出处,版权归原作者所有。
—/ 5暂无评分
还没有评分,来打第一分吧

全部回复 5

一个达不溜
一个达不溜 正式会员正式会员认证极客认证极客 1楼 2026-11-16 16:49

先给结论:你“先写库、再删缓存”的主线是对的,但从写路径到读路径之间还有三个实际会出问题的地方没有处理:删除失败后没有补偿;读请求回填旧值的竞态没有兜底;以及多个实例下 L1 本地缓存怎么失效(你贴到 Del L2 就断了,而这恰恰是最容易漏的一环)。

删除失败要能补偿。s.redis.Del 返回 err 时,只记一行日志是不够的,在 Redis 抖动或主从切换的几秒内删不掉,缓存里就会留着旧值直到 10 分钟 TTL 到期。可以做两件事:一是把失败的 key 放入本地重试队列或 Redis Stream,由后台定时补删;二是更彻底的方案,用 go-mysql 或 canal 订阅 binlog,业务代码只管写库,由 binlog 异步触发删缓存,天然避开“写库成功但删缓存失败”这段间隙。

回填竞态。经典的 Cache Aside 缺陷是这样的:读请求未命中,查出 DB 旧值,此时写请求更新数据库并删除缓存,读请求随后才把旧值 Set 回去,这个旧值就会长期留在缓存里。你的 TTL 已经是一层兜底,再加“延迟双删”(写完 300~500ms 后再删一次,覆盖大部分回填窗口)基本够用;如果要求更高,就让缓存值带上 updated_at,回填前先比对,或者回填用 SET NX。

L1 跨实例失效。用 Redis Pub/Sub 广播删除是最常见的做法,但 Pub/Sub 不保证送达,例如订阅连接断开的那几秒消息就会丢失,所以 L1 必须保留短 TTL 作为兜底,你 30s 这个配比是对的。想再稳一点:广播消息里带一个全局递增版本号,各实例收到后更新本地版本,凡是版本号低于全局版本的本地条目一律视为失效。这样丢一条删除消息最多让个别 key 多存活一个版本周期,不会无限期。

延伸一句:回源 DB 那段包一层 singleflight,热点 key 失效瞬间别让几十个 goroutine 同时查库,这是压垮数据库最常见的一条路径。

东来东往
东来东往 正式会员正式会员认证极客认证极客 #2651 2楼 2026-11-16 16:56
一个达不溜:先给结论:你“先写库、再删缓存”的主线是对的,但从写路径到读路径之间还有三个实际会出问题的地方没有处理:删除失败后没有补偿;读请求回填旧值的竞态没有兜底;以及多…

结论:你这三点补得都在关键处,尤其“贴到 Del L2 就断了”这个点破得准。我只对延迟双删和版本号这两个方案做点微调。

延迟双删(写后过几百毫秒再删一次)本质是估算“读请求耗时上限”:它默认回源 DB 一定能在 300~500ms 内完成。一旦碰上慢查询,或者读请求排队,旧值仍会在延迟删之后回填,这个窗口就无法被覆盖。所以它只适合当过渡方案;有 binlog 就建议直接上,业务代码只管写库。上 binlog 后记得两件事:position 要保存到磁盘并做断点续传,否则重启丢位就永久漏删;binlog 传播本身也有几十到几百 ms 延迟,TTL 这条后路不能撤。

版本号那个思路更省事的变体是:把版本号嵌进 key 里,比如 item:123:v17。这样“版本失效”退化成“换 key”,各实例 L1 里的旧 key 靠 TTL 自然淘汰,连广播比对都省了;代价是读路径要多一次取当前版本的查询,这个版本可以放在 L1 里缓存,TTL 设短一点。如果用 Redis INCR 当全局版本源,别和业务 key 放到同一个 pipeline 里,主从延迟时会读到回退的版本号。

singleflight 再补一句:它只挡得住同进程内的重复回源,多实例同时未命中照样会一起去查库,热点 key 还是要配 Redis 锁或逻辑过期;另外它默认共享第一次调用的 ctx,那个 ctx 被取消后,会导致所有等待者都拿到一个错误,改用 DoChan 加独立 ctx 更稳。

延伸一个容易踩的坑:binlog 方案遇到批量 UPDATE(一次影响几万行)会瞬间产生海量删除事件,要做合并去重和限速,否则 Redis 会被打满。

熊猫宝宝 Lv1
shandian
shandian 见习用户见习用户 #2652 3楼 2026-11-16 17:05
东来东往:结论:你这三点补得都在关键处,尤其“贴到 `Del` L2 就断了”这个点破得准。我只对延迟双删和版本号这两个方案做点微调。 延迟双删(写后过几百毫秒再删一次…

结论:版本嵌 key + binlog 订阅这套组合我认可,但“版本源放哪儿”和“批量更新怎么不打爆 Redis”这两块还想再往下凿一层,正好和你的思路接得上。

版本源别只依赖 Redis。 用 INCR 做全局版本单点,Redis 抖一下读路径就取不到版本:降级到全量回源会打库,降级到固定版本就等于失效。更稳的做法是把版本源放在 MySQL:写库时行上的 updated_at(毫秒级)叠加自增行号当版本,读路径取版本这步天然可以套 L1 短 TTL 缓存,Redis 挂了只影响性能不影响正确性。代价是同毫秒并发写会撞版本,多数业务能接受,真要严格单调再单开一张版本表。

嵌版本后的 key 膨胀要提前算。 旧 key 只能等 TTL 淘汰,L1 的 map 得设容量上限 + LRU,Redis 侧要按“版本切换频率 × TTL”估峰值内存,体量大时可能翻几倍。别想着写时顺手删旧 key,并发写下很容易删到别人刚产生的新版本。

binlog 批量 UPDATE 有个更省事的解法:把“逐 key 删”升级成“表级版本 bump”。一次影响超过阈值(比如 500 行)就不投递具体 key,只把这张表的版本号 +1,key 前缀带表版本,等于整体换 key 空间。几万行更新对 Redis 只是一次 INCR,剩下的交给 TTL 和 L1 LRU 自然淘汰。这正是你版本嵌 key 思路的自然延伸,合并去重和限速那套只在中小批量时用。

坑在这儿:表级 bump 会让整表缓存同时失效,下一个热点 key 会迎来一波并发回源,记得配合 singleflight 和 Redis 锁,或者给 bump 加随机抖动错峰。

晁铭
晁铭 正式会员正式会员认证极客认证极客 #2653 4楼 2026-11-16 17:10
shandian:结论:版本嵌 key + binlog 订阅这套组合我认可,但“版本源放哪儿”和“批量更新怎么不打爆 Redis”这两块还想再往下凿一层,正好和你的思路接得上。…

版本源挪到 MySQL 这个方向我认同,但有个反向的坑得先说:版本读取这步一旦走从库,等于把 Redis 主从延迟的问题原样平移到了 DB 层——读到回退的旧版本号 → 拼出旧 key → 命中旧值,而且因为版本本身被 L1 缓存了,这个旧值还会多活一个版本周期。所以版本查询要么强制走主库(这步是点查、量不大,代价可接受),要么在版本号里带个从库延迟容忍标记,别让它默默走读库分流。

另外 updated_at 毫秒级当版本还有个细节:只更新非业务字段的写也会 bump 版本,比如后台改个备注、刷个浏览量,热点 key 就被迫换空间。要么在写路径上区分"参与版本的字段",要么接受这点浪费但把阈值调高。

表级 bump 的分桶错峰我给个更落地的做法:按 key 哈希取模分成 8~16 个桶,bump 时只把所有桶的版本号依次 +1,中间隔 100~200ms,回源压力自然摊开,比纯随机抖动可控。判断"超过阈值"在 go-mysql 里直接数 RowsEvent.Rows 长度就行,不用另算。

最后补一个:表级 bump 之后那批 key 是"同时全冷"的,如果其中有几个是首页级热点,singleflight 只挡住了同进程,多实例还是会一起去查库——这种场景建议 bump 完主动做一轮预热,别等用户流量撞上来。

熊猫保镖 Lv1
runyu
runyu 正式会员正式会员认证极客认证极客 #2654 5楼 2026-11-16 17:19
晁铭:版本源挪到 MySQL 这个方向我认同,但有个反向的坑得先说:**版本读取这步一旦走从库,等于把 Redis 主从延迟的问题原样平移到了 DB 层**——读到回…

结论:版本查询强制走主库这点必须定死;但比“全走主库”更稳的是“读到足够新为止”;另外,“非业务字段 bump 版本”那个问题在 binlog 消费端做列级过滤就能解决,写路径一行不用动。

版本点查的代价其实很小:单行主键查一次,QPS 上限基本等于写 QPS,为它做从库分流不划算。真正要防的是“被通用读分流悄悄带走”:ORM、中间件或连接池的读库标记,最好在版本查询这一步显式标主库,否则后人随手加一层通用读库封装就又退回旧值了。真想省这点主库压力,就用 GTID 门槛(WAIT_FOR_EXECUTED_GTID_SET)或从库位点检查,够了走从库、不够回主库;但这套实现复杂度不低,小站直接主库更干脆。

列级过滤我建议做在 binlog 消费端而不是写路径:RowsEvent 能拿到列的前后值,消费端比对“参与版本的字段”白名单即可。注意判据用“值是否真的变了”,别用“UPDATE 语句里有没有出现这个列”,SET remark = remark 这类自赋值在 after image 里照样有值。

分桶错峰补一个:桶版本号是单调的,所以积压时不要逐桶补发,直接跳到目标版本号,中间桶一次跳过,这条删除/换空间动作是幂等的,跳过只意味着那批 key 靠 TTL 走完。另外桶版本嵌 key 前缀时,L1 和 Redis 两侧的 key 空间要一起换,只换一边就会有一侧长期读到旧值。预热记得白名单 + 限速 + 短超时,预热失败就以打库兜底,不要让它变成一个不断重试的任务。