内容总览

Redis 缓存实践与常见问题 思维导图

一、起源:把缓存理论落到工程时要回答的问题

1.1 从“能读写”到“缓存可信”

缓存的基本收益是把重复的读请求从数据库转移到内存,把响应耗时从毫秒级降到亚毫秒级,同时把数据库的读压力按命中率线性削减。代价是同一份数据出现两个副本:权威数据在数据库,工作副本在缓存。两个副本之间的差异需要被设计约束,而不是被默认忽略。

只做到“读时查缓存、写时删缓存”,程序可以正常运行,但在下列条件下会表现为数据错误或服务不可用:并发请求同时未命中、缓存失效与数据库更新交叉执行、缓存实例发生故障转移、键的空间随时间失控增长。因此缓存代码的评审重点不在命令使用,而在时序、并发与失效路径。

1.2 工程落地必须回答的问题

问题 不回答的后果 落地位置
键怎么设计 键冲突与互相覆盖、无法按业务前缀清理、集群下同一业务数据分散在多个节点 3.1 节
数据以什么格式存储 反序列化失败、字段变更后旧值不可读、value 膨胀占用内存 3.1 节
并发未命中时如何回源 同一秒内成百上千个请求同时查库,数据库瞬时压力放大 2.1 节与 3.4 节
锁如何可靠获取与释放 死锁或锁提前释放,业务出现重复执行或长时间阻塞 2.2 节与 3.3 节
缓存与数据库不一致如何收敛 读到旧值,且不一致窗口无界 3.5 节
缓存问题(穿透、击穿、雪崩)如何处置 大量请求直达数据库,缓存从加速层变为单点 2.8 节与 3.4 节
内存与键规模如何受控 内存写满触发淘汰或写入拒绝,命中率坍塌 2.7 节与 3.7 节
什么数据可以放进缓存 把不可重建、不可丢失的数据当作缓存使用,故障后无法恢复 1.3 节与 3.8 节

1.3 缓存的适用范围与边界

缓存中的数据应满足可重建性:缓存内容丢失后,能够从权威数据源按需重新生成,或允许在短时间内缺失。由此推出三条边界:

  1. 缓存不是权威数据源。写入缓存成功不代表业务成功;业务写入必须以数据库为权威,缓存只承载读取加速;
  2. 缓存不做可靠投递。以列表或流作为队列使用时缺少确认、重投与位点语义,进程重启会丢任务,需要可靠性时应使用消息队列,分工见 3.8 节;
  3. 缓存不承担正确性保证。分布式锁、缓存去重之类的能力在故障转移与网络分区下存在失效窗口,正确性应由数据库唯一约束、状态条件更新或幂等键承担,相关设计参见 消息可靠性与幂等设计 第 2.5 节。

二、原理

2.1 缓存读写路径的落地形态

读路径

请求 → 查询缓存
  ├─ 命中 → 反序列化 → 返回
  └─ 未命中 → 回源数据库 → 回填缓存(带 TTL)→ 返回

读路径的四个落地要点:

  1. 回填必须带 TTL。无 TTL 的键会长期占用内存,并且当业务逻辑变化后,旧值不会被自然淘汰;
  2. 回源结果为空时,需要区分“确实不存在”与“本次未缓存”,处理方式见 3.4 节的空值缓存;
  3. 回填失败不应影响本次返回。回填是优化动作,不是业务动作;
  4. 缓存操作异常时的默认方向是回源数据库,而不是向上抛出异常,否则缓存抖动会直接变成业务不可用。

写路径

主流做法是旁路缓存(Cache Aside):先更新数据库,再删除缓存,缓存由读路径在下次访问时重建。

写请求 → 更新数据库(提交事务)→ 删除缓存 → 返回

选择删除而不是更新缓存,原因有三点:

  1. 更新缓存需要重新计算结果值,而某些缓存值由多个数据源聚合而成,写入路径计算成本高于读路径;
  2. 并发更新下,两次“更新缓存”的顺序可能与数据库提交顺序相反,缓存被写入更旧的值;
  3. 删除是幂等操作,重试代价低;写入缓存的部分失败会留下错误值,删除失败只是让下次读多一次回源。

先删缓存再更新数据库的问题

该顺序在并发下存在固定的错误窗口:删除缓存后、数据库提交前,另一个读请求未命中并读到旧值回填缓存,此后数据库才提交新值,缓存中长期保留旧值。修正手段是延迟双删(更新数据库后延迟再删一次),实现见 3.5 节;更彻底的做法是让失效由变更日志驱动。

回填时的并发控制

未命中瞬间的并发量与键的热度成正比。三种控制方式的取舍:

方式 行为 代价 适用
互斥重建 未命中时抢占锁,只有一个请求回源,其余请求等待后重读缓存 等待期间请求被阻塞,锁本身可能成为瓶颈 回源成本高、键热度高
逻辑过期 值中携带逻辑过期时间,过期后返回旧值并由后台异步刷新 存在一段返回旧值的时间,需要异步线程与刷新失败的重试 可容忍短暂旧值、不允许请求阻塞
单飞合并(本地) 单实例内相同键的并发回源合并为一次调用 只覆盖单实例,多实例仍需分布式互斥 回源成本高但键热度集中在单实例

三种方式都不改变一个前提:回源结果必须整体回填,且回填与数据库更新之间仍可能存在窗口,最终一致性由失效路径保证。

2.2 分布式锁的基本要求

分布式锁用于把跨进程的临界区串行化,典型场景是缓存重建、定时任务选主、幂等占位;其中缓存重建针对的击穿问题与互斥重建的取舍见 缓存基础与一致性 第 2.6 节。可靠实现需要同时满足五项要求:

要求 含义 不满足的后果
互斥 同一时刻只有一个持有者 临界区被并发进入,保护失效
超时释放 锁有 TTL,持有者崩溃后可自动释放 锁永久残留,相关业务全部阻塞
可重入 同一持有者可重复获取 同一线程内嵌套获取时自我阻塞
可续期 业务耗时超过 TTL 时可延长 业务未完成锁已释放,出现并发执行
安全释放 只允许持有者释放 释放他人锁,临界区被第三方进入

SET NX EX 的最小实现

SET lock:rebuild:item:1001 <token> NX EX 10

该命令本身是原子的,作为最小实现可满足互斥与超时释放,但存在五项不足:

  1. TTL 与业务耗时不匹配。TTL 小于实际耗时则锁提前释放,其余请求进入临界区;TTL 过大则持有者崩溃后长时间阻塞;
  2. 释放需要校验持有者。DEL 会删除任何持有者的锁,必须先比较 token 再删除,且比较与删除需在服务端原子执行(见 3.3 节);
  3. 不可重入。同一线程再次获取同一锁会被自己阻塞,需要额外记录持有者与重入计数;
  4. 故障转移可能丢失锁。主从异步复制下,主节点写入锁后未同步即故障,从节点提升后锁消失,互斥被破坏;
  5. 无续期能力。业务耗时不可预估时,TTL 只能按最坏情况放大。

看门狗续期机制

客户端(如 Redisson)在未指定租期时启用看门狗:获取锁后记录租期(默认 30 秒,对应 lockWatchdogTimeout),后台任务按租期的三分之一周期(默认每 10 秒)检查持有者是否仍持有锁,仍持有则续期,释放时停止续期。需要注意三点:

  1. 显式指定租期(leaseTime)时不启用看门狗,锁到期即释放,业务耗时必须小于租期;
  2. 续期依赖客户端进程存活与网络可达,长时间 GC 停顿、线程池耗尽或网络中断都会造成续期失败;
  3. 看门狗只解决“业务耗时超过租期”,不解决“客户端已失联但租期未到”的互斥重叠窗口,重叠期间的正确性仍由业务幂等兜底。

Redlock 的争议与适用边界

Redlock 的思路是在多个相互独立的实例上依次加锁,获得多数派则认为加锁成功。争议集中在两个假设上:一是各节点时钟推进速率有界,二是网络延迟远小于锁租期。当出现长时间 GC 停顿、时钟跳变或网络大规模延迟时,同一时刻可能有两个持有者同时认为持有锁,互斥性被破坏。因此适用边界为:对性能不敏感、可接受极小概率的互斥失效、且失效后果由业务兜底可收敛的场景;不适合把互斥性当作正确性唯一前提的场景(例如扣减类操作的唯一防线)。

锁的降级与失败处理

锁的作用是减少重复工作与资源争抢,而不是保证业务结果正确。由此得到两条处理原则:

  1. 获取锁失败时应有确定行为:快速失败返回降级结果(例如返回上一次的缓存值、进入限流队列),或短暂等待后重试,并且重试必须有次数上限与退避,避免锁竞争本身形成流量自激;
  2. 对正确性敏感的操作应保留数据库侧兜底约束(唯一键、状态条件更新、版本号),使锁失效时的重复执行可被识别与拒绝,相关做法参见 消息可靠性与幂等设计 第 3.4 节。

2.3 限流的常见实现

算法 Redis 侧实现 精度与特点 代价
固定窗口 INCR 计数 + EXPIRE,超过阈值拒绝 实现最简单;窗口边界处可能出现约两倍阈值的瞬时通过 计数键数量与窗口数成正比
滑动窗口 以时间戳为 score 写入 zset,先 ZREMRANGEBYSCORE 清理过期成员,再 ZCARD 计数 精度高,无边界突刺 每条请求一次写入,内存与 O(logN) 开销随阈值增长
令牌桶 Lua 脚本内按时间差补充令牌,取令牌与补充在同一脚本中原子执行 允许突发到桶容量,符合多数业务预期 需脚本保证原子性,逻辑复杂度较高
漏桶 以固定速率取出请求,超出容量排队或拒绝 输出速率平滑,不放大突发 排队引入额外延迟

落地时的三个细节:

  1. 过期时间只设一次。使用 EXPIRE key ttl NX(或由 Lua 脚本判断)避免每次 INCR 都重置 TTL,否则窗口永远不会结束;
  2. 时间源统一取服务端时间。多实例部署时使用 Redis 服务器时间(TIME 命令或 Lua 内的 redis.call('TIME')),避免客户端时钟漂移造成各实例判定不一致;
  3. 明确降级方向。限流器依赖的 Redis 不可用时,必须提前确定是放行(保护用户体验、放弃保护后端)还是拒绝(保护后端、放弃部分流量),该方向需与业务方确认,不能由框架默认值决定。

限流的阈值本身需要基线数据支撑,阈值取值方法与压测方式参见 linux: 性能测试与基线 第 3.4 节。

2.4 计数与统计

原子计数

INCR、INCRBY、HINCRBY、ZINCRBY 在服务端单线程执行,天然原子,适合计数器、库存预占、接口调用次数等场景。使用要点:

  1. 计数键必须设置 TTL 或按周期归档,否则计数键会随维度增长而无界累积;
  2. 计数与限流复用同一个键时,需要区分“会计数”与“会被拒绝”的边界,避免把拒绝的请求也计入成功量;
  3. 计数结果只反映 Redis 侧的状态,与数据库的真实值之间可能存在差异,对账口径需明确。

独立访客(UV)统计

方案 精度 内存开销 能力边界
SET 集合 精确 与基数成正比,百万级用户占用显著 支持判断单个用户是否访问过
HyperLogLog 标准误差约 0.81%,基数较小时误差相对更大 每键固定约 12KB 只提供基数估算,不能判断单个元素是否存在,支持 PFMERGE 合并
bitmap 位图 精确 与用户标识的最大值成正比(按位) 要求用户标识为连续整数或可映射为连续下标

选择依据是“是否需要判断单个用户”与“标识是否可映射为连续整数”。UV 属于允许误差的统计类数据,HyperLogLog 是常用选择;需要精确去重且用户标识可映射时使用 bitmap;集合方案仅在基数可控(万级以内)时使用。

2.5 排行榜与有序集合

有序集合(zset)由哈希表与跳表组成,按 score 排序并支持按 member 定位,插入与查询为 O(logN),适合排行榜、延迟任务、时间窗口限流三类结构。

常用命令与用途:

ZINCRBY rank:daily 1 user:1001        # 原子累加分值
ZREVRANGE rank:daily 0 9 WITHSCORES   # 取前 10 名
ZREVRANK rank:daily user:1001         # 查询某成员的名次(从 0 开始)
ZRANGEBYSCORE rank:daily 100 +inf LIMIT 0 20   # 按分值范围取成员

落地边界:

  1. 分值精度。score 为双精度浮点数,整数精确表示范围为 ±2^53,时间戳(毫秒级,约 1.7×10^12)可直接作为 score;若把分值放大(例如按 1000 倍存储小数),需确认放大后的数值仍在精确范围内;
  2. 深分页。ZRANGE start stop 的偏移量随 N 增大而变慢,榜位很深时应改用游标方式:以上一页最后一条的 score 作为下界,ZRANGEBYSCORE key (lastScore +inf LIMIT 0 N,或对同分场景在 score 中拼接时间戳以形成稳定次序;
  3. 榜外数据裁剪。只保留 TopN 时需在写入后调用 ZREMRANGEBYRANK 删除超出部分,否则集合会持续增长并为大 key 埋下隐患;
  4. 同分排序。score 相同时按 member 的字典序排列,若需要“先达到者在前”,应把时间戳编码进 score 的低位;
  5. 可重算性。榜单若可由业务数据重算,可不做持久化;不可重算时应定期把 zset 快照落库,避免实例故障后榜单丢失。

2.6 延时队列与轻量任务调度

方案一:zset 轮询

以任务的可见时间(毫秒时间戳)作为 score 写入 zset,轮询取出到期任务。

写入:ZADD queue:delay <readyTs> <taskId>
取出:ZRANGEBYSCORE queue:delay 0 <now> LIMIT 0 N
      → 对每个任务执行或投递
      → 成功后 ZREM queue:delay <taskId>

要点:

  1. 取出与删除需原子。多消费者并发轮询时,先用 Lua 脚本一次性取出并删除到期成员,再执行任务;先取后删会在两步之间产生重复处理;
  2. 失败处理要留痕。任务执行失败需要记录并重新入队(更新 score 为下一次可见时间)或转入失败集合,否则任务会永久消失;
  3. 空轮询的代价。ZRANGEBYSCORE 在无到期任务时仍会执行一次范围查询,高频轮询会占用 CPU 与网络;应设置轮询间隔或使用阻塞式等待配合本地定时器。

方案二:Stream 消费者组

# 生产:写入任务
XADD task:stream * type ORDER_TIMEOUT orderNo O20260922123456
# 建组:从队列头部开始消费
XGROUP CREATE task:stream workerGroup 0
# 消费:读取新消息,超时 2 秒返回
XREADGROUP GROUP workerGroup worker1 COUNT 10 BLOCK 2000 STREAMS task:stream >
# 处理成功后确认
XACK task:stream workerGroup 1700000000000-0
# 查看未确认消息(含空闲时长)
XPENDING task:stream workerGroup
# 认领超时未确认的消息
XCLAIM task:stream workerGroup worker2 60000 1700000000000-0

Stream 的可见时间由写入时间决定,不直接支持“延迟到指定时刻可见”,实现延时任务需要配合外部调度或轮询读取;其优势在于内置消息 ID、消费者组、未确认列表与认领机制。

两种方案的对比

维度 zset 轮询 Stream 消费者组
延迟精度 取决于轮询间隔 由调度方式决定,配合定时读取可控
投递可靠性 无确认语义,需自行实现重试与失败记录 有 XACK 与 XPENDING,支持 XCLAIM 重投
重复消费 需 Lua 保证取出即删除 至少一次语义,需消费端幂等
消费进度 无位点概念,任务即数据 有消费者组位点
数据清理 任务执行后即删除,无堆积 确认后不自动删除,需 XTRIM 或 XADD MAXLEN 控制长度
有序性 按 score 排序 按消息 ID 递增

选择依据:任务量可控、可容忍丢失、只需“到点触发”时用 zset;需要确认、重投与消费进度时用 Stream;需要跨系统可靠投递、复杂重试拓扑与死信管理时使用消息队列,见 3.8 节。

2.7 大 key 与热 key 的治理

判定标准

“大”与“热”都是相对实例容量与带宽的相对概念,工程上需要给出可执行的判定阈值。经验口径:

类型 大 key 判定参考
String value 大于 10KB 需关注,大于 1MB 视为大 key
Hash、List、Set、ZSet 元素数量大于 5000,或总字节数大于 1MB
Stream 长度超过数万条且未裁剪

热 key 的判定依据是访问分布的集中度:单键的 QPS 占实例总 QPS 的比例显著突出,或在集群中出现分片间 CPU 与网络明显不均。

影响范围

  1. 主线程阻塞。单条命令的复杂度随元素数量增长,HGETALL、SMEMBERS、DEL 等操作在大 key 上会长时间占用主线程,同一实例上的其他请求全部排队;
  2. 网络与客户端缓冲。响应体过大占用网络带宽与客户端内存,输出缓冲区异常增长可能触发连接被强制关闭;
  3. 复制与持久化。写大 key 会放大复制缓冲区;fork 期间的写操作触发页复制,内存占用上升;AOF 重写与 RDB 保存的耗时随之拉长;
  4. 集群扩容与迁移。槽迁移以 key 为单位,单个大 key 的迁移会造成迁移超时与阻塞;
  5. 删除代价。DEL 大 key 需要释放全部元素,属于同步操作,会阻塞主线程。

识别手段

手段 方式 说明
redis-cli --bigkeys 基于 SCAN 采样各类型元素数量 只给出元素数量口径,不反映字节数;采样结果需按比例还原
redis-cli --hotkeys 依赖 LFU 淘汰策略统计访问频率 实例需使用 allkeys-lfu 或 volatile-lfu
MEMORY USAGE key 返回单键内存占用 逐个键执行,适合复核可疑键
SCAN + 类型命令 按前缀遍历并统计长度 可自定义统计维度,注意控制扫描速率
离线分析 RDB 解析 RDB 文件统计键大小分布 无在线影响,适合周期性评估
MONITOR 短时采样 捕获实际命令流 开销大,只允许短时间、单节点使用
客户端或代理埋点 统计键的访问次数与耗时 精度最高,需要接入层改造

治理方式

  1. 拆分。按业务维度把大 Hash 拆为多个子键(例如按用户 ID 取模分片),或把大 String 拆为分片字段;
  2. 打散。同一业务键在集群中集中到一个分片时,可在键中加入分片后缀并使用多个逻辑键轮转,把压力分散到不同槽;
  3. 本地缓存与多级缓存。只读或极少变更的数据放入进程内缓存,热点读不再访问 Redis;结构见 3.6 节;
  4. 读写改造。用 HSCAN、SSCAN、ZSCAN 分批读取替代整集合读取;写路径合并高频更新,降低单键压力;
  5. 删除改造。使用 UNLINK 异步删除,或按类型分批删除(HSCAN 后 HDEL、SSCAN 后 SREM、ZREMRANGEBYRANK),控制单次操作的元素数量。

2.8 缓存穿透、击穿、雪崩的工程侧处置清单

本节只给出工程侧动作,穿透、击穿、雪崩的成因与通用应对见 缓存基础与一致性 第 2.5 节至第 2.7 节。

问题 触发条件 工程侧处置 处置代价
穿透 查询的数据在数据库中也不存在,缓存永远不会命中 空值缓存并设置较短 TTL;布隆过滤器提前拦截;入口参数校验与频率限制 空值键占用内存;过滤器存在假阳性且元素不可删除
击穿 单个热点键在过期瞬间被大量并发请求同时回源 互斥重建;逻辑过期加异步刷新;热点键不设 TTL 并主动更新 互斥造成等待;异步刷新存在返回旧值的窗口
雪崩 大量键在同一时间失效,或缓存实例整体不可用 TTL 加随机抖动;按业务分批预热与刷新;多级缓存;限流与降级;实例层的副本与集群 抖动使 TTL 不可精确预估;多级缓存引入一致性维护成本
冷启动 发布、重启或扩容后缓存为空 上线前按业务清单预热;分批加载并限速;发布窗口与数据库容量匹配 预热脚本本身需要维护,且需控制对数据库的冲击

四项处置的共同前提是:缓存失效不允许演化为数据库的瞬时压力。因此失效路径需要限流保护,数据库侧需要预留余量,缓存不可用时的降级方向需要提前确定。

三、实现

3.1 键设计规范与序列化选择

键命名

{环境}:{业务域}:{对象}:{标识}[:{维度}]

prod:user:profile:10086
prod:item:detail:20001
prod:rank:daily:20260922

规则与理由:

  1. 冒号分层,便于按前缀统计与批量清理,也便于在监控面板中按业务域聚合;
  2. 全小写,避免不同客户端对大小写的处理差异造成键分裂;
  3. 键长度需要权衡:键自身占用内存,1 亿个 50 字节的键约占用 5GB 量级内存,规划容量时必须计入;
  4. 集群模式下需要多键操作(如 Lua 脚本内访问、MGET)落在同一槽时,用花括号声明 hash tag,例如 prod:cart:{10086}:items,同一 {10086} 的记录落在同一槽;
  5. 不使用可变业务字段作为键(例如用户手机号),字段变更会造成键迁移与旧键残留;
  6. 前缀是批量清理与权限收敛的基础,缺失前缀的键难以安全删除,见 3.7 节。

序列化选择

方式 体积 可读性 兼容性 适用与注意
JSON 中等 好,可直接查看 字段增删较宽容,类型信息弱(数值与字符串易混淆) 通用选择,适合中小 value 与跨语言访问
JDK 原生序列化 大 不可读 与类名、序列号绑定,跨版本易失败 不建议用于缓存,存在反序列化安全风险
Protobuf、Hessian、Kryo 等二进制 小 不可读 依赖 schema 或类型注册,演进需受控 适合 value 较大或吞吐敏感的场景
压缩后的 JSON 或二进制 最小 需解压后查看 继承底层格式的兼容性 value 达到数 KB 以上时收益明显,代价是 CPU 与排障成本

选型结论:默认使用 JSON;value 较大或 QPS 很高时切换为二进制格式并保留 schema 版本;跨版本升级时通过键前缀(v1、v2)或值内版本字段实现双读,避免新旧格式互相不可解析。格式选择的方法论参见 java: 序列化 第 5.6 节。

反序列化失败的处理需要有确定路径:记录键名与原始内容、删除该键、回源重建。静默返回空对象会让错误长期存在。

3.2 读路径与写路径的代码结构

手动缓存:读路径

public UserProfile getProfile(long userId) {
    String key = "prod:user:profile:" + userId;
    try {
        String cached = stringRedisTemplate.opsForValue().get(key);
        if (cached != null) {
            return NULL_MARK.equals(cached) ? null : JSON.parseObject(cached, UserProfile.class);
        }
    } catch (Exception e) {
        // 缓存不可用:记录后直接回源,避免缓存抖动放大为业务不可用
        log.warn("cache read failed, fallback to db, key={}", key, e);
        return profileMapper.selectById(userId);
    }
    // 未命中:回源并回填(回填的并发控制在 3.4 节展开)
    UserProfile profile = profileMapper.selectById(userId);
    writeCache(key, profile);
    return profile;
}

手动缓存:写路径

@Transactional(rollbackFor = Exception.class)
public void updateProfile(UserProfile profile) {
    profileMapper.updateById(profile);                 // 先更新数据库
    String key = "prod:user:profile:" + profile.getId();
    // 事务提交成功后再删除缓存,避免事务回滚后缓存已被删除或被重新写入旧值
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
        @Override
        public void afterCommit() {
            try {
                stringRedisTemplate.delete(key);
            } catch (Exception e) {
                // 删除失败不影响主流程,交由补偿任务处理
                log.error("cache evict failed, key={}", key, e);
            }
        }
    });
}

缓存注解与手动缓存的取舍

维度 @Cacheable、@CacheEvict 等注解 手动读写
代码量 少,声明式 多,需要显式处理命中、回源、回填
过期时间 按 cacheName 统一配置,细粒度需要多个 cacheName 逐键控制
空值 默认不缓存空值,需开启并处理 自行决定是否写空值标记
批量失效 支持不足,按模式清理需要额外实现 可自行实现
调用约定 同类内部调用不走代理,注解不生效 无此限制
异常与降级 默认异常直接抛出,需要自定义 CacheErrorHandler 分支明确,降级路径可控

选择原则:结构简单的只读配置类数据用注解以降低样板代码;涉及热点重建、空值缓存、批量失效、降级兜底的核心链路使用手动缓存。Spring Cache 与 Redis 的配置方式、序列化器设置参见 springboot: 实践 第 4.3 节;连接池、超时等配置项参见 springboot: application.yml 第三章。

连接与超时配置需要显式设置,禁止使用默认的无限等待:

spring:
  data:
    redis:
      host: 127.0.0.1
      port: 6379
      timeout: 500ms
      lettuce:
        pool:
          max-active: 16
          max-wait: 200ms

超时时间应小于接口的整体超时预算,使缓存故障能在可接受的时间内退化为回源,而不是把接口整体拖超时。

3.3 分布式锁的落地

加锁与解锁的完整实现

private static final String UNLOCK_LUA =
        "if redis.call('get', KEYS[1]) == ARGV[1] then "
      + "  return redis.call('del', KEYS[1]) "
      + "else "
      + "  return 0 "
      + "end";

/** 加锁成功返回持有的 token,失败返回 null */
public String tryLock(String key, Duration ttl) {
    String token = UUID.randomUUID().toString();
    Boolean ok = stringRedisTemplate.opsForValue().setIfAbsent(key, token, ttl);
    return Boolean.TRUE.equals(ok) ? token : null;
}

/** 释放锁:只有持有者本人可以释放 */
public void unlock(String key, String token) {
    stringRedisTemplate.execute(
            new DefaultRedisScript<>(UNLOCK_LUA, Long.class),
            Collections.singletonList(key),
            token);
}

解锁脚本单独说明(比较与删除必须在服务端一次完成,否则两步之间锁可能过期并被他人获取,造成误删):

-- KEYS[1]:锁键  ARGV[1]:加锁时写入的 token
if redis.call('get', KEYS[1]) == ARGV[1] then
  return redis.call('del', KEYS[1])
else
  return 0
end

调用侧必须把释放放在 finally 中,并确认异常路径不会跳过释放:

public void rebuild(String key) {
    String lockKey = "lock:rebuild:" + key;
    String token = tryLock(lockKey, Duration.ofSeconds(10));
    if (token == null) {
        return;                       // 未获取到锁:快速失败,由调用方重读缓存或降级
    }
    try {
        doRebuild(key);
    } finally {
        unlock(lockKey, token);
    }
}

锁超时与业务耗时不匹配的处理

情形 表现 处理方式
TTL 小于业务耗时 锁提前释放,临界区被并发进入 TTL 按业务耗时的 P99 取数倍,或启用看门狗续期;临界区内的操作保持幂等
TTL 远大于业务耗时 持有者崩溃后长时间阻塞 TTL 不宜超过业务可容忍的阻塞时间;配合监控与人工清理流程
客户端暂停导致续期失败 续期失败后锁到期释放 缩短临界区、避免在临界区内做大批量操作与远程调用

锁粒度选择与嵌套规避

  1. 锁粒度按业务主体确定,例如 lock:order:{orderNo},避免使用全局锁导致所有请求串行;
  2. 临界区只覆盖必须互斥的最小片段,不在持锁期间执行远程调用、批量循环与慢查询;
  3. 避免锁嵌套:嵌套会造成两个线程以相反顺序获取锁而互相等待,形成死锁;若确实需要多把锁,应统一获取顺序或合并为一把锁;
  4. 同一实例内的并发优先使用本地锁(如 ReentrantLock),只有跨实例的互斥才使用分布式锁,可显著降低 Redis 压力。

使用现成客户端时的租期约定

RLock lock = redisson.getLock("lock:order:" + orderNo);
// 等待 1 秒获取,租期 10 秒:到期强制释放,业务耗时必须小于租期
boolean locked = lock.tryLock(1, 10, TimeUnit.SECONDS);
if (locked) {
    try {
        doBiz();
    } finally {
        lock.unlock();
    }
}

不传租期时启用看门狗续期(默认 30 秒,按三分之一周期续期)。选择依据是业务耗时是否可预估:可预估且远小于租期时显式指定租期,避免续期带来的额外命令;不可预估时依赖续期,同时保留业务侧幂等兜底。

3.4 防击穿与防穿透的落地

互斥重建与双重检查

public UserProfile getWithMutex(long userId) {
    String key = "prod:user:profile:" + userId;
    String cached = stringRedisTemplate.opsForValue().get(key);
    if (cached != null) {
        return decode(cached);
    }
    String lockKey = "lock:rebuild:user:profile:" + userId;
    String token = tryLock(lockKey, Duration.ofSeconds(5));
    if (token == null) {
        // 未获取到锁:短暂等待后重读缓存;仍无则回源(不无限等待)
        sleepQuietly(50);
        String again = stringRedisTemplate.opsForValue().get(key);
        return again != null ? decode(again) : profileMapper.selectById(userId);
    }
    try {
        String again = stringRedisTemplate.opsForValue().get(key);   // 双重检查
        if (again != null) {
            return decode(again);
        }
        UserProfile profile = profileMapper.selectById(userId);
        writeCache(key, profile);        // 含空值缓存
        return profile;
    } finally {
        unlock(lockKey, token);
    }
}

等待时间的取值需要与接口超时预算一起确定:等待过短会使未获取到锁的请求直接回源,等于没有保护;等待过长会把缓存故障放大为接口超时。

逻辑过期

值中携带逻辑过期时间,键本身不设 TTL:

static class Wrapper<T> {
    long expireAt;      // 逻辑过期时间(毫秒时间戳)
    T data;
}

public UserProfile getWithLogicExpire(long userId) {
    String key = "prod:user:profile:" + userId;
    Wrapper<UserProfile> w = readWrapper(key);
    if (w == null) {
        return profileMapper.selectById(userId);          // 首次未命中,同步加载
    }
    if (System.currentTimeMillis() < w.expireAt) {
        return w.data;
    }
    // 已逻辑过期:返回旧值,同时触发一次带互斥的异步刷新
    asyncRefresher.refreshIfAbsent(key);
    return w.data;
}

异步刷新任务内部仍需互斥,避免过期后大量请求同时触发刷新;刷新失败时保留旧值并记录,等待下一轮触发,同时需要有兜底策略防止旧值长期不更新(例如连续失败达到阈值后改为同步刷新)。

空值缓存

private static final String NULL_MARK = "__NULL__";
private static final Duration NULL_TTL = Duration.ofSeconds(60);

private void writeCache(String key, UserProfile profile) {
    if (profile == null) {
        // 用独立标记与短 TTL 表示“确认不存在”,与“未缓存”区分开
        stringRedisTemplate.opsForValue().set(key, NULL_MARK, NULL_TTL);
    } else {
        stringRedisTemplate.opsForValue().set(key, JSON.toJSONString(profile), Duration.ofMinutes(30));
    }
}

空值 TTL 需要与业务写入路径配合:数据被创建后必须确保对应空值键被删除,否则新数据在 TTL 内仍表现为不存在。

布隆过滤器

过滤器用于在访问缓存与数据库之前拦截必然不存在的键。位数组容量与哈希个数按预期元素数量 n 与可接受误判率 p 估算:

m = -n × ln(p) / (ln2)^2     位数组长度
k = (m / n) × ln2            哈希函数个数

例:n = 1,000,000,p = 0.01
    m ≈ 9,600,000 位(约 1.2MB),k ≈ 7

实现途径有三类:

途径 使用方式 约束
Redis 位图自实现 SETBIT、GETBIT 加多个哈希函数 需自行实现扩容与重建,位图本身是大 key 风险点
Redis 布隆模块 BF.RESERVE、BF.ADD、BF.EXISTS 依赖模块可用性;误判率与容量需在建键时指定
进程内过滤器 启动时加载全量标识生成 多实例需各自加载,数据变更需同步或周期性重建

三个必须遵守的约束:

  1. 存在假阳性,没有假阴性。过滤器判断存在时仍需查缓存与数据库,只有判断不存在才可直接返回;
  2. 元素不可删除。数据删除后过滤器仍认为存在,误判率随删除量上升;需要周期性重建,重建时使用影子过滤器双写,待新过滤器加载完成后切换;
  3. 只覆盖可枚举的键空间。过滤器适合“标识集合”可预先加载的场景(如商品 ID、用户 ID),不适合按任意参数组合查询的键。

3.5 数据库与缓存一致性方案的代码化

一致性的目标不是消除差异,而是把不一致窗口压缩到业务可接受的范围,并让差异可收敛。为此不引入跨库事务,而是围绕“更新数据库 + 失效缓存 + 补偿”组合手段。

延迟双删

public void updateWithDoubleDelete(Item item) {
    String key = "prod:item:detail:" + item.getId();
    stringRedisTemplate.delete(key);                 // 第一次删除
    itemMapper.updateById(item);                     // 更新数据库
    // 延迟第二次删除,覆盖“并发读回填旧值”的窗口
    delayTaskService.schedule(() -> stringRedisTemplate.delete(key),
                              Duration.ofMillis(500));
}

延迟时间的取值依据:延迟时间大于“主从复制延迟 + 一次回源查询耗时”,即大于从库或缓存的读副本可能读到旧值的最大时间跨度。复制延迟的构成与影响因素参见 mysql: 主从复制原理 第 2.7 节。

延迟任务本身必须可持久化(落库后由定时任务扫描,或投递到消息队列),否则进程重启会丢失第二次删除;第二次删除失败需要有重试与记录。

定时补偿

定时任务扫描近期变更记录(业务表的时间戳字段或变更日志表),对近期被修改的键做一次删除或重写。补偿只解决“删除失败”与“延迟任务丢失”,不解决时序错乱,因此仍需与延迟双删或变更日志方案配合。

变更日志驱动失效

由数据库的二进制日志(binlog)解析出数据变更,投递到消息队列,由消费者删除对应缓存键。

数据库写入 → binlog → 采集组件解析 → 变更事件投递到消息队列
           → 消费者按“表 + 主键”计算键名 → 删除缓存 → 提交消费位点

优点:业务代码无侵入,删除动作与数据库提交顺序一致,可从指定位点重放补偿历史失效。缺点:链路长、存在秒级延迟,需要处理批量变更与结构性变更,且消费端必须幂等(同一条变更被重复消费时删除操作本身幂等,但计数、重建类动作不幂等)。binlog 的记录格式与位点语义参见 mysql: 主从复制原理 第 2.8 节;消费端幂等设计参见 消息可靠性与幂等设计 第 2.5 节。

方案对比

方案 不一致窗口 实现成本 适用
先删缓存再更新数据库 并发读回填旧值,窗口不可控 低 低并发或无并发写入的场景
先更新数据库再删缓存 删除失败时长期不一致 低 通用默认方案
延迟双删 缩短至延迟时间量级 中,需延迟任务与补偿 读写并发较高且能接受短窗口
变更日志驱动失效 由链路延迟决定,通常秒级 高,需采集组件与消息队列 多语言、多写入入口、要求与业务代码解耦
写路径同时更新缓存 无失效窗口,但存在写乱序风险 中 写少读多且值计算简单

无论采用哪种方案,缓存侧都必须设置 TTL 作为最终兜底:TTL 是“不一致自动收敛”的上界,缺失 TTL 时一次失效失败会变成永久不一致。

3.6 多级缓存的落地

多级缓存把读路径拆为“进程内缓存 → 分布式缓存 → 数据库”三层,用于降低热点键对 Redis 的访问压力与网络往返。

层级 实现 容量与 TTL 约束 适用数据
进程内 Caffeine、Guava Cache、自实现 Map 必须设置最大条目数与过期时间,否则会造成内存持续增长 只读或极少变更、可容忍短暂不一致的数据
分布式 Redis 按业务设置 TTL,与本地缓存 TTL 配合 全量业务数据
数据库 权威数据源 无 兜底

失效传播方式

方式 过程 优点 缺点
仅靠 TTL 兜底 本地缓存到期后自然失效 实现最简单,无额外组件 变更可见延迟等于本地 TTL
消息广播失效 变更后投递广播消息,各实例收到后清除本地键 延迟低 消息丢失会造成长期不一致,必须叠加 TTL 兜底
发布订阅失效 通过 Redis 频道广播失效消息 无需额外组件 订阅连接断开期间的消息会丢失,仍需 TTL 兜底
版本号校验 本地缓存记录版本,读时比对远端版本 精确 每次读都产生一次远端查询,削弱本地缓存收益

一致性取舍

本地缓存的 TTL 决定“最坏情况下多久看到新值”,这一时间必须与业务确认。变更频繁(分钟级变化)的数据不宜放入本地缓存;确需放入时,应使用广播失效加短 TTL 的组合,并把本地缓存 TTL 作为上界写入设计说明。

两个必须落实的约束:本地缓存必须有容量上限(无上限的 Map 等同于内存泄漏),必须有过期时间(无过期的本地缓存会让一致性依赖人工重启)。

3.7 常见线上问题与处置

现象 常见成因 定位手段 处置
缓存与数据库不一致 删除调用在事务内被回滚、删除失败未补偿、延迟任务丢失、读写乱序 比对缓存值与数据库值,检查删除调用的事务边界与失败日志 改为事务提交后删除;补延迟删除与定时补偿;必要时引入变更日志驱动失效
热点键导致单节点压力 单键 QPS 集中、大 key 上的高频访问、集群分片不均 查看集群各节点 CPU 与网络差异、使用 --hotkeys 或客户端埋点统计 键打散、本地缓存分担、读写合并;必要时拆分为多个逻辑键
键数量暴涨 键无 TTL、用请求参数直接拼键导致基数不可控、穿透写入了大量空值键 按前缀统计键数量,观察键数量的增长斜率 为大类键设置 TTL;限制键基数(对参数做白名单或哈希收敛);修正空值缓存 TTL
内存持续增长 碎片率升高、存在未裁剪的 List 或 Stream、复制缓冲区累积、无 TTL 键堆积 INFO memory 观察 used_memory、mem_fragmentation_ratio;大 key 扫描 开启碎片整理、裁剪集合、补充 TTL、排查缓冲区;必要时扩容或分片
锁未释放导致业务阻塞 异常路径漏掉释放、TTL 过大、客户端已断开但锁仍存在 按锁前缀列出键并查看 TTL 与值 修复 finally 释放与 TTL 配置;人工清理前确认无业务正在持有(属高危操作)
批量键失效引发回源风暴 统一 TTL 同时到期、批量清理动作同时删除大量键 观察缓存命中率与数据库 QPS 的时间相关性 TTL 加随机抖动、清理分批并限速、提前预热、数据库侧限流保护

需要标记的高危操作

高危:按模式批量删除缓存键(例如 KEYS 后批量删除,或 SCAN 匹配后集中删除)会在同一时刻使大量键失效,回源流量可能直接压垮数据库;KEYS 命令本身还会阻塞主线程。兜底方式:确认被删除的键均可从权威数据源重建;使用 SCAN 分批并限制单批数量与执行频率,在业务低峰执行;删除前确认数据库容量并准备限流;生产环境不使用 KEYS 做全量匹配。

高危:FLUSHDB 与 FLUSHALL 会清空当前库或该实例上全部库的数据,操作不可撤销。兜底方式:执行前确认实例与库编号、确认该实例未被其他业务共用、确认库内数据均可从权威数据源重建;优先以按前缀分批删除替代整库清空;如确需清空,先保留一份 RDB 备份并确认恢复流程可用。

高危:删除或修改正在被业务持有的分布式锁键(例如人为清理“看似残留”的锁)会导致同一时刻出现两个持有者,破坏互斥。兜底方式:清理前核对锁键的 TTL、值与业务日志,确认无业务正在临界区内;优先通过缩短 TTL、修复释放逻辑与业务幂等兜底来消除残留锁,而不是人工删除。

3.8 与消息队列的分工

缓存与消息队列解决的问题不同,混用会造成可靠性缺陷:

需求 缓存(含 List、Stream) 消息队列
读加速 适用 不适用
削峰填谷 不适用 适用
可靠投递与重投 List 无确认语义,进程重启即丢;Stream 有确认但运维能力有限 适用,具备确认、重试、死信与位点
异步解耦与跨系统事件 不适用 适用
消费进度与积压观测 Stream 有限支持 完整支持

用 List 充当队列的典型缺陷:消费失败无法重投、没有消费位点、BRPOP 之后的处理失败需要自行重新入队、缺少死信与积压指标。因此只有“任务可丢失且量级很小”的场景才考虑用缓存承载队列,其余场景使用消息队列,价值与代价的对比参见 消息队列基础 第 1.2 节与第 1.3 节,投递语义参见同文第 2.4 节。

两者的常见协作方式是“数据库 + 消息队列 + 缓存失效”:写路径更新数据库后投递失效事件,消费端删除缓存,删除动作可重试、可幂等、可观测;相比应用内直接删除,可靠性更高但引入链路延迟与运维成本。

缓存去重与幂等的关系需要明确:缓存侧的 SET NX 占位只用于在高吞吐下拦截重复,最终正确性由数据库唯一约束或状态条件更新保证,相关设计参见 消息可靠性与幂等设计 第 2.5 节与第 3.3 节。

四、总结

  • 缓存的收益来自读请求转移到内存,代价是出现数据副本,因此键设计、时序、并发控制与失效处置是评审重点,而不是命令用法
  • 数据进入缓存的前提是可重建;缓存不承载权威数据、不保证投递、不承担正确性
  • 读路径为“查缓存、命中返回、未命中回源并回填”,回填必须带 TTL 且失败不影响主流程;写路径为“先更新数据库、再删除缓存”,删除优于更新
  • 未命中并发通过互斥重建、逻辑过期或本地单飞合并控制,三者的取舍是等待时间与旧值可见窗口的取舍
  • 分布式锁需满足互斥、超时释放、可重入、可续期与安全释放;SET NX EX 只是起点,释放必须校验持有者,故障转移与 GC 停顿下互斥可能失效,正确性需业务兜底
  • 限流按固定窗口、滑动窗口、令牌桶与漏桶实现,精度与开销递增;必须明确 Redis 不可用时的放行或拒绝方向
  • 计数与统计应区分精确与近似:HyperLogLog 用误差换内存,bitmap 要求标识可映射为连续下标,集合方案仅适用于小基数
  • 排行榜依托有序集合的有序性与范围查询,需注意分值精度、深分页、榜外裁剪与可重算性
  • 延时队列可用 zset 轮询或 Stream 消费者组,前者简单但无确认语义,后者有确认与认领但需自行裁剪;需要可靠投递时应使用消息队列
  • 大 key 与热 key 会阻塞主线程、放大复制与持久化开销、拖慢槽迁移;治理手段是拆分、打散、本地缓存分担与分批读写,删除大 key 应使用异步或分批方式
  • 穿透、击穿、雪崩的处置分别落在空值与过滤器、互斥与逻辑过期、TTL 抖动与多级缓存上,共同前提是不让缓存失效演化为数据库瞬时压力
  • 一致性的可行路径是先更新数据库再删缓存并叠加延迟双删、定时补偿或变更日志驱动失效,TTL 是不可省略的最终兜底
  • 多级缓存降低热点访问压力,但本地缓存必须有容量上限与过期时间,一致性依赖失效传播加 TTL 兜底
  • FLUSHDB、FLUSHALL、按模式批量删除、人工清理锁键属于高危操作,执行前必须确认可重建性、影响范围与回滚方式