内容总览
一、起源:把缓存理论落到工程时要回答的问题
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 缓存的适用范围与边界
缓存中的数据应满足可重建性:缓存内容丢失后,能够从权威数据源按需重新生成,或允许在短时间内缺失。由此推出三条边界:
- 缓存不是权威数据源。写入缓存成功不代表业务成功;业务写入必须以数据库为权威,缓存只承载读取加速;
- 缓存不做可靠投递。以列表或流作为队列使用时缺少确认、重投与位点语义,进程重启会丢任务,需要可靠性时应使用消息队列,分工见 3.8 节;
- 缓存不承担正确性保证。分布式锁、缓存去重之类的能力在故障转移与网络分区下存在失效窗口,正确性应由数据库唯一约束、状态条件更新或幂等键承担,相关设计参见 消息可靠性与幂等设计 第 2.5 节。
二、原理
2.1 缓存读写路径的落地形态
读路径
请求 → 查询缓存
├─ 命中 → 反序列化 → 返回
└─ 未命中 → 回源数据库 → 回填缓存(带 TTL)→ 返回
读路径的四个落地要点:
- 回填必须带 TTL。无 TTL 的键会长期占用内存,并且当业务逻辑变化后,旧值不会被自然淘汰;
- 回源结果为空时,需要区分“确实不存在”与“本次未缓存”,处理方式见 3.4 节的空值缓存;
- 回填失败不应影响本次返回。回填是优化动作,不是业务动作;
- 缓存操作异常时的默认方向是回源数据库,而不是向上抛出异常,否则缓存抖动会直接变成业务不可用。
写路径
主流做法是旁路缓存(Cache Aside):先更新数据库,再删除缓存,缓存由读路径在下次访问时重建。
写请求 → 更新数据库(提交事务)→ 删除缓存 → 返回
选择删除而不是更新缓存,原因有三点:
- 更新缓存需要重新计算结果值,而某些缓存值由多个数据源聚合而成,写入路径计算成本高于读路径;
- 并发更新下,两次“更新缓存”的顺序可能与数据库提交顺序相反,缓存被写入更旧的值;
- 删除是幂等操作,重试代价低;写入缓存的部分失败会留下错误值,删除失败只是让下次读多一次回源。
先删缓存再更新数据库的问题
该顺序在并发下存在固定的错误窗口:删除缓存后、数据库提交前,另一个读请求未命中并读到旧值回填缓存,此后数据库才提交新值,缓存中长期保留旧值。修正手段是延迟双删(更新数据库后延迟再删一次),实现见 3.5 节;更彻底的做法是让失效由变更日志驱动。
回填时的并发控制
未命中瞬间的并发量与键的热度成正比。三种控制方式的取舍:
| 方式 | 行为 | 代价 | 适用 |
|---|---|---|---|
| 互斥重建 | 未命中时抢占锁,只有一个请求回源,其余请求等待后重读缓存 | 等待期间请求被阻塞,锁本身可能成为瓶颈 | 回源成本高、键热度高 |
| 逻辑过期 | 值中携带逻辑过期时间,过期后返回旧值并由后台异步刷新 | 存在一段返回旧值的时间,需要异步线程与刷新失败的重试 | 可容忍短暂旧值、不允许请求阻塞 |
| 单飞合并(本地) | 单实例内相同键的并发回源合并为一次调用 | 只覆盖单实例,多实例仍需分布式互斥 | 回源成本高但键热度集中在单实例 |
三种方式都不改变一个前提:回源结果必须整体回填,且回填与数据库更新之间仍可能存在窗口,最终一致性由失效路径保证。
2.2 分布式锁的基本要求
分布式锁用于把跨进程的临界区串行化,典型场景是缓存重建、定时任务选主、幂等占位;其中缓存重建针对的击穿问题与互斥重建的取舍见 缓存基础与一致性 第 2.6 节。可靠实现需要同时满足五项要求:
| 要求 | 含义 | 不满足的后果 |
|---|---|---|
| 互斥 | 同一时刻只有一个持有者 | 临界区被并发进入,保护失效 |
| 超时释放 | 锁有 TTL,持有者崩溃后可自动释放 | 锁永久残留,相关业务全部阻塞 |
| 可重入 | 同一持有者可重复获取 | 同一线程内嵌套获取时自我阻塞 |
| 可续期 | 业务耗时超过 TTL 时可延长 | 业务未完成锁已释放,出现并发执行 |
| 安全释放 | 只允许持有者释放 | 释放他人锁,临界区被第三方进入 |
SET NX EX 的最小实现
SET lock:rebuild:item:1001 <token> NX EX 10
该命令本身是原子的,作为最小实现可满足互斥与超时释放,但存在五项不足:
- TTL 与业务耗时不匹配。TTL 小于实际耗时则锁提前释放,其余请求进入临界区;TTL 过大则持有者崩溃后长时间阻塞;
- 释放需要校验持有者。
DEL会删除任何持有者的锁,必须先比较 token 再删除,且比较与删除需在服务端原子执行(见 3.3 节); - 不可重入。同一线程再次获取同一锁会被自己阻塞,需要额外记录持有者与重入计数;
- 故障转移可能丢失锁。主从异步复制下,主节点写入锁后未同步即故障,从节点提升后锁消失,互斥被破坏;
- 无续期能力。业务耗时不可预估时,TTL 只能按最坏情况放大。
看门狗续期机制
客户端(如 Redisson)在未指定租期时启用看门狗:获取锁后记录租期(默认 30 秒,对应 lockWatchdogTimeout),后台任务按租期的三分之一周期(默认每 10 秒)检查持有者是否仍持有锁,仍持有则续期,释放时停止续期。需要注意三点:
- 显式指定租期(leaseTime)时不启用看门狗,锁到期即释放,业务耗时必须小于租期;
- 续期依赖客户端进程存活与网络可达,长时间 GC 停顿、线程池耗尽或网络中断都会造成续期失败;
- 看门狗只解决“业务耗时超过租期”,不解决“客户端已失联但租期未到”的互斥重叠窗口,重叠期间的正确性仍由业务幂等兜底。
Redlock 的争议与适用边界
Redlock 的思路是在多个相互独立的实例上依次加锁,获得多数派则认为加锁成功。争议集中在两个假设上:一是各节点时钟推进速率有界,二是网络延迟远小于锁租期。当出现长时间 GC 停顿、时钟跳变或网络大规模延迟时,同一时刻可能有两个持有者同时认为持有锁,互斥性被破坏。因此适用边界为:对性能不敏感、可接受极小概率的互斥失效、且失效后果由业务兜底可收敛的场景;不适合把互斥性当作正确性唯一前提的场景(例如扣减类操作的唯一防线)。
锁的降级与失败处理
锁的作用是减少重复工作与资源争抢,而不是保证业务结果正确。由此得到两条处理原则:
- 获取锁失败时应有确定行为:快速失败返回降级结果(例如返回上一次的缓存值、进入限流队列),或短暂等待后重试,并且重试必须有次数上限与退避,避免锁竞争本身形成流量自激;
- 对正确性敏感的操作应保留数据库侧兜底约束(唯一键、状态条件更新、版本号),使锁失效时的重复执行可被识别与拒绝,相关做法参见 消息可靠性与幂等设计 第 3.4 节。
2.3 限流的常见实现
| 算法 | Redis 侧实现 | 精度与特点 | 代价 |
|---|---|---|---|
| 固定窗口 | INCR 计数 + EXPIRE,超过阈值拒绝 | 实现最简单;窗口边界处可能出现约两倍阈值的瞬时通过 | 计数键数量与窗口数成正比 |
| 滑动窗口 | 以时间戳为 score 写入 zset,先 ZREMRANGEBYSCORE 清理过期成员,再 ZCARD 计数 | 精度高,无边界突刺 | 每条请求一次写入,内存与 O(logN) 开销随阈值增长 |
| 令牌桶 | Lua 脚本内按时间差补充令牌,取令牌与补充在同一脚本中原子执行 | 允许突发到桶容量,符合多数业务预期 | 需脚本保证原子性,逻辑复杂度较高 |
| 漏桶 | 以固定速率取出请求,超出容量排队或拒绝 | 输出速率平滑,不放大突发 | 排队引入额外延迟 |
落地时的三个细节:
- 过期时间只设一次。使用
EXPIRE key ttl NX(或由 Lua 脚本判断)避免每次INCR都重置 TTL,否则窗口永远不会结束; - 时间源统一取服务端时间。多实例部署时使用 Redis 服务器时间(
TIME命令或 Lua 内的redis.call('TIME')),避免客户端时钟漂移造成各实例判定不一致; - 明确降级方向。限流器依赖的 Redis 不可用时,必须提前确定是放行(保护用户体验、放弃保护后端)还是拒绝(保护后端、放弃部分流量),该方向需与业务方确认,不能由框架默认值决定。
限流的阈值本身需要基线数据支撑,阈值取值方法与压测方式参见 linux: 性能测试与基线 第 3.4 节。
2.4 计数与统计
原子计数
INCR、INCRBY、HINCRBY、ZINCRBY 在服务端单线程执行,天然原子,适合计数器、库存预占、接口调用次数等场景。使用要点:
- 计数键必须设置 TTL 或按周期归档,否则计数键会随维度增长而无界累积;
- 计数与限流复用同一个键时,需要区分“会计数”与“会被拒绝”的边界,避免把拒绝的请求也计入成功量;
- 计数结果只反映 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 # 按分值范围取成员
落地边界:
- 分值精度。score 为双精度浮点数,整数精确表示范围为 ±2^53,时间戳(毫秒级,约 1.7×10^12)可直接作为 score;若把分值放大(例如按 1000 倍存储小数),需确认放大后的数值仍在精确范围内;
- 深分页。
ZRANGE start stop的偏移量随 N 增大而变慢,榜位很深时应改用游标方式:以上一页最后一条的 score 作为下界,ZRANGEBYSCORE key (lastScore +inf LIMIT 0 N,或对同分场景在 score 中拼接时间戳以形成稳定次序; - 榜外数据裁剪。只保留 TopN 时需在写入后调用
ZREMRANGEBYRANK删除超出部分,否则集合会持续增长并为大 key 埋下隐患; - 同分排序。score 相同时按 member 的字典序排列,若需要“先达到者在前”,应把时间戳编码进 score 的低位;
- 可重算性。榜单若可由业务数据重算,可不做持久化;不可重算时应定期把 zset 快照落库,避免实例故障后榜单丢失。
2.6 延时队列与轻量任务调度
方案一:zset 轮询
以任务的可见时间(毫秒时间戳)作为 score 写入 zset,轮询取出到期任务。
写入:ZADD queue:delay <readyTs> <taskId>
取出:ZRANGEBYSCORE queue:delay 0 <now> LIMIT 0 N
→ 对每个任务执行或投递
→ 成功后 ZREM queue:delay <taskId>
要点:
- 取出与删除需原子。多消费者并发轮询时,先用 Lua 脚本一次性取出并删除到期成员,再执行任务;先取后删会在两步之间产生重复处理;
- 失败处理要留痕。任务执行失败需要记录并重新入队(更新 score 为下一次可见时间)或转入失败集合,否则任务会永久消失;
- 空轮询的代价。
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 与网络明显不均。
影响范围
- 主线程阻塞。单条命令的复杂度随元素数量增长,
HGETALL、SMEMBERS、DEL等操作在大 key 上会长时间占用主线程,同一实例上的其他请求全部排队; - 网络与客户端缓冲。响应体过大占用网络带宽与客户端内存,输出缓冲区异常增长可能触发连接被强制关闭;
- 复制与持久化。写大 key 会放大复制缓冲区;fork 期间的写操作触发页复制,内存占用上升;AOF 重写与 RDB 保存的耗时随之拉长;
- 集群扩容与迁移。槽迁移以 key 为单位,单个大 key 的迁移会造成迁移超时与阻塞;
- 删除代价。
DEL大 key 需要释放全部元素,属于同步操作,会阻塞主线程。
识别手段
| 手段 | 方式 | 说明 |
|---|---|---|
redis-cli --bigkeys | 基于 SCAN 采样各类型元素数量 | 只给出元素数量口径,不反映字节数;采样结果需按比例还原 |
redis-cli --hotkeys | 依赖 LFU 淘汰策略统计访问频率 | 实例需使用 allkeys-lfu 或 volatile-lfu |
MEMORY USAGE key | 返回单键内存占用 | 逐个键执行,适合复核可疑键 |
SCAN + 类型命令 | 按前缀遍历并统计长度 | 可自定义统计维度,注意控制扫描速率 |
| 离线分析 RDB | 解析 RDB 文件统计键大小分布 | 无在线影响,适合周期性评估 |
MONITOR 短时采样 | 捕获实际命令流 | 开销大,只允许短时间、单节点使用 |
| 客户端或代理埋点 | 统计键的访问次数与耗时 | 精度最高,需要接入层改造 |
治理方式
- 拆分。按业务维度把大 Hash 拆为多个子键(例如按用户 ID 取模分片),或把大 String 拆为分片字段;
- 打散。同一业务键在集群中集中到一个分片时,可在键中加入分片后缀并使用多个逻辑键轮转,把压力分散到不同槽;
- 本地缓存与多级缓存。只读或极少变更的数据放入进程内缓存,热点读不再访问 Redis;结构见 3.6 节;
- 读写改造。用
HSCAN、SSCAN、ZSCAN分批读取替代整集合读取;写路径合并高频更新,降低单键压力; - 删除改造。使用
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 亿个 50 字节的键约占用 5GB 量级内存,规划容量时必须计入;
- 集群模式下需要多键操作(如 Lua 脚本内访问、
MGET)落在同一槽时,用花括号声明 hash tag,例如prod:cart:{10086}:items,同一{10086}的记录落在同一槽; - 不使用可变业务字段作为键(例如用户手机号),字段变更会造成键迁移与旧键残留;
- 前缀是批量清理与权限收敛的基础,缺失前缀的键难以安全删除,见 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 不宜超过业务可容忍的阻塞时间;配合监控与人工清理流程 |
| 客户端暂停导致续期失败 | 续期失败后锁到期释放 | 缩短临界区、避免在临界区内做大批量操作与远程调用 |
锁粒度选择与嵌套规避
- 锁粒度按业务主体确定,例如
lock:order:{orderNo},避免使用全局锁导致所有请求串行; - 临界区只覆盖必须互斥的最小片段,不在持锁期间执行远程调用、批量循环与慢查询;
- 避免锁嵌套:嵌套会造成两个线程以相反顺序获取锁而互相等待,形成死锁;若确实需要多把锁,应统一获取顺序或合并为一把锁;
- 同一实例内的并发优先使用本地锁(如
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 | 依赖模块可用性;误判率与容量需在建键时指定 |
| 进程内过滤器 | 启动时加载全量标识生成 | 多实例需各自加载,数据变更需同步或周期性重建 |
三个必须遵守的约束:
- 存在假阳性,没有假阴性。过滤器判断存在时仍需查缓存与数据库,只有判断不存在才可直接返回;
- 元素不可删除。数据删除后过滤器仍认为存在,误判率随删除量上升;需要周期性重建,重建时使用影子过滤器双写,待新过滤器加载完成后切换;
- 只覆盖可枚举的键空间。过滤器适合“标识集合”可预先加载的场景(如商品 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、按模式批量删除、人工清理锁键属于高危操作,执行前必须确认可重建性、影响范围与回滚方式