进程内 Ristretto + Redis:两级缓存怎么配才不互相坑

进程内 Ristretto + Redis:两级缓存怎么配才不互相坑

Hello,我是小兔大白糖。 压测一上来,Redis 上几个热点 key 的 QPS 先炸;同学说「再套一层进程内缓存」——听起来对,但 L1 写漏、多实例各一份内存,往往比单层 Redis 更难查。写成这篇,给已经用过 Redis、想给热路径加一层进程内缓存的后端同学。

说明:示例均为教学脱敏 / 示意。读完带走的是读写约定与取舍,不是可粘贴的生产封装。

估计阅读时间:9 分钟


目录


为什么现在要关心

热点读打满 Redis 时,进程内缓存能挡一刀;挡错了,你会同时踩「本机旧值」和「跨机不一致」。

常见现场:

你看到的现象常见真相
Redis CPU / 连接被少数 key 打满热路径每次都穿透到 L2,没有本机命中
「加了本地缓存」后偶发读到旧配置写了 Redis,本机 L1 没删;或多实例各有一份 L1
双写「更安全」却出现半成功Redis 成功、L1 失败(或反过来),两边长期对不齐
以为 Ristretto「落了盘」重启还在进程内缓存跟进程同生共死,本来就不是持久层

并发扇出怎么收成有界池,见 /blog/goroutine_explosion_worker_pool/。本文只钉一件事:L1 挡本机热读,L2 做跨实例共享;读写约定先写清,再谈库怎么配。


心智模型:书桌便利贴 vs 楼层文件柜

主比喻:办公楼里的便签与文件柜。

  • 书桌便利贴(L1 / Ristretto):伸手就拿,最快;只贴在你这张桌上;下班走人(进程退出)就没了;同事桌上各贴各的,互不相通。
  • 楼层文件柜(L2 / Redis):整层同事都能开柜取同一份;可以带「过期撕掉」的标签(TTL);比便利贴慢一截,但解决「跨工位共享」。
两级缓存读路径:先 L1 Ristretto,再 L2 Redis,未命中回源并回填
两级缓存读路径:先 L1 Ristretto,再 L2 Redis,未命中回源并回填 · 点击查看 SVG 原图

类比局限一句说清:便签 / 文件柜解释「速度、作用域、是否共享」;解释不了淘汰策略细节(如条目 cost、计数器规模)——那些是容量与命中率调参,不是「持久化」。


精确定义:L1 与 L2 各管什么

两级缓存 = 同一逻辑键,先查本机内存,再查共享层;共享层不是「耐久数据库」的替身。

层典型实现速度作用域进程重启本文角色
L1Ristretto(进程内)极快单进程全丢挡本机热读
L2Redis快,但仍是网络往返多实例共享取决于你怎么用 Redis共享缓存(常带 TTL)

原稿里常见的两处硬伤,先纠正:

  1. Ristretto 不是持久化层。 它活在进程堆里;重启、滚动发布、OOM 杀进程,L1 清空。别把它当成「带索引的本地磁盘库」。
  2. Redis 在这套组合里,首要卖点是共享与 TTL,不是「耐久数据库」。 Redis 可以开 RDB/AOF,但两级缓存讨论里,你通常要的是:多副本进程读同一份热数据。真正的 source of truth 仍是业务库 / 上游服务;L2 挂了应能回源,而不是假装「库没了」。

容量上只记一句人话即可:进程内缓存常有 MaxCost(总预算) 和单条 cost(这条占多少预算)——预算满了会淘汰,不是「写进去就永远在」。具体字段以你用的库版本文档为准,本文不展开调参公式。


读写约定:一张表说清

读:L1 → L2 → 回源;写:先保证共享层正确,再处理本机 L1。

路径约定为什么
读命中 L1直接返回挡掉对本机已有热数据的 Redis 往返
读 miss L1,命中 L2回填 L1,再返回下次本机打满前少打 Redis
读双 miss回源 → 写 L2(及按策略写/不写 L1)L2 是跨实例的「最近真相」缓存面
写(推荐默认)更新 L2(或先更新源再写 L2)→ 删 / 失效本机 L1少一次「双写半成功」;下次读从 L2 回填
写(双写)同时写 L1 + L2本机立刻热,但要付一致性与半成功账单

教学示意(伪流程,非生产 API;合计约十几行):

READ(key):
  if v := L1.get(key); hit → return v
  if v := L2.get(key); hit → L1.set(key, v); return v
  v := source.load(key)
  L2.set(key, v, ttl)
  L1.set(key, v)   // 可选:也可等下次读再回填
  return v

WRITE(key, v):          // 更常见:写共享层 + 失效本机
  source.save(key, v)   // 若源在库里
  L2.set(key, v, ttl)   // 或删 L2,逼全员回源——看一致性要求
  L1.del(key)           // 关键:别留本机旧便利贴

账单先说清:多一层 L1,就多一次「本机是否过期」的心智负担;省下的是热点 key 对 Redis 的往返与连接压力。


双写 vs 写后失效:取舍

默认更稳的是「写 L2(或写源)+ 删本机 L1」;双写换本机立刻热,用半成功和更难对齐的状态付钱。

策略本机下次读失败形态适合
写后失效 L1多一次 L2 或回源,再回填L2 已新、L1 已空 → 短暂变慢,不易「新旧并存」配置、权限、多数业务读多写少
简单双写 L1+L2本机立刻命中新值L1 成功 L2 失败(或反过来)→ 长期半边旧单实例、能接受复杂重试 / 对账,或写极少且可观测

再钉一条多实例事实:

  • 每个 Pod / 进程各有一份 L1。实例 A 失效了自己的便利贴,实例 B 桌上可能还贴着旧的。
  • 直到 B 的条目被淘汰、TTL 到期、或 B 也执行失效,L1 之间可以短暂不一致。L2(Redis)才是跨实例对齐用的共享面——前提是你写路径真的更新或删了 L2。

若业务「绝对不能读到旧值」:要么缩短 / 去掉 L1、要么写时广播失效(额外组件与延迟)、要么读时带版本校验——每条都有代价,别只喊「加本地缓存」。


常见坑

  1. 把 Ristretto 当成落盘存储
    滚动发布后「缓存怎么空了」——空是正常的。持久化诉求应落在源库或明确设计的存储,不在 L1。

  2. 把 Redis 只当「耐久库」来卖这套架构
    两级缓存的收益是共享热数据与 TTL;耐久与备份是另一条线。源挂了只剩 Redis,不等于业务可永久离线跑。

  3. 写了 Redis 忘了删本机 L1
    本机继续命中旧便利贴,看起来像「Redis 没写上」。先查失效,再查 L2。

  4. 多实例下指望 L1 强一致
    各进程内存独立。短暂旧读是默认物理现实;要强一致就别把真相只放在 L1。

  5. 双写却没有半成功处理
    一次网络抖动就能留下「一边新一边旧」。没有重试、对账或「以 L2 为准再修 L1」,双写比失效更脆。

  6. L1 预算(MaxCost)过小或 cost 乱标
    热 key 进不去或进了立刻被挤掉,L1 形同虚设,Redis 照样被打满——这是容量问题,不是「两级架构无效」。


小结

  1. L1 = 本机极速、非持久、不跨机(Ristretto);L2 = 跨实例共享缓存(Redis),不是这套故事里的「耐久数据库替身」。
  2. 读路径:L1 → L2 → 回源;L2 命中后回填 L1。
  3. 写路径默认:更新源 / L2 后 失效本机 L1;双写能换本机立刻热,但要付半成功与对账账单。
  4. 多实例:各有一份 L1,允许短暂不一致;跨机对齐靠 L2(或回源),不靠「每台内存碰巧一样」。
  5. 账单:少打 Redis 热点,换来失效纪律与「本机可能旧一点」——省掉的 QPS 和加出来的排障,是同一笔账。

下一步:画出你服务里热 key 的读占比 → 确认写路径是否删本机 L1 → 多副本压测时故意改一条配置看旧值窗口 → 再决定要不要双写或缩短 L1 TTL。权威阅读以你锁定的 Ristretto / Redis 版本文档为准。