一个商品详情页在凌晨做了一次缓存迁移,Redis 里的键被清空。迁移完成后不到三分钟,数据库连接数从两百涨到九百,CPU 打满,所有依赖这个库的接口一起超时。值班的人先扩容数据库,再重启应用,都没用;最后把缓存预热回去,流量才落下来。事后复盘发现两件事:一是缓存清空后没有任何预热和限流,所有读请求同时回源;二是缓存里的过期时间几乎都是同一个整点,之后每天到了那个点,都会出现一次小型的回源尖峰。

这类事故的共同点是:缓存平时把问题盖住了,一旦它不在,问题就以十倍的速度暴露。所以评价一套缓存,不能只看「平时命中率多少」,还要看「它失效的瞬间,后端能不能接住」。

这篇先讲缓存放在哪一层,再讲命中率和回源量怎么算,然后把穿透、击穿、雪崩三种故障分别拆开。文中的模型数据来自本机 Node 仿真;Redis 部分在本机用 5.0.14.1 移植版真跑过,端口 6381,内存上限设为 32MB,淘汰策略 allkeys-lru。

先认出现象:缓存出事的几种样子

缓存的问题往往不在缓存本身,而在「缓存和数据库之间没有约定」。下面这些现象经常成组出现。

现象真实原因第一步查什么
缓存重启后数据库连接瞬间打满缓存全空,所有读同时回源,没有预热和限流看回源 QPS 曲线与数据库连接数是否同步陡增
命中率长期只有三成键设计太散、生命周期太短,或缓存的数据根本不是热点统计键的访问频次分布与平均存活时间
某个不存在的 ID 被反复查询缓存穿透,查询结果为空所以永远不缓存看空结果请求的占比与来源 IP
整点前后数据库周期性抖动大量键设置了相同过期时间,集中失效看过期时间的分布直方图,而不是平均值
单个热键过期瞬间后端超时缓存击穿,并发请求同时去重建同一个键看该键重建期间的并发回源次数
内存没满但开始大量淘汰淘汰策略与数据特征不匹配,热数据被冷数据挤掉看 evicted_keys 增速与命中率变化
缓存和数据库数值对不上更新顺序或并发写导致短暂不一致查写路径是先删缓存还是先写库,是否有延迟双删
大键读取拖慢整个实例单个键体积过大,序列化与网络传输占满时间用扫描命令找出最大的键及其访问频率

缓存放在哪一层

「缓存」不是一个组件,而是一串位置。同一个数据可以在浏览器、CDN、应用进程内存、集中式 Redis、数据库自带缓冲里各存一份。越靠前越快、越省后端,但越难保证新鲜;越靠后越一致,但每次都要多走一段路。

浏览器缓存靠响应头控制,适合图片、脚本、不常变的配置。命中时请求根本不出用户设备,最省钱,但你无法主动清除。
CDN 边缘缓存适合静态资源和可公开的接口结果。按 URL 缓存,改一个查询参数就是另一个对象,键设计不当会大幅掉命中率。
应用进程内缓存存在每个应用实例的内存里。纳秒级,但多实例之间不一致,进程重启即失效,只适合极热且能容忍短暂陈旧的数据。
集中式缓存就是常说的 Redis 或 Memcached。多实例共享,容量大,能主动删除,代价是多一次网络往返和一套要运维的组件。
数据库缓冲数据库自己的内存池,不需要你管,但只能加速它已经读过的数据,挡不住第一次查询和写压力。

大多数业务系统说的「加缓存」,指的是第四层。它适合读多写少、能容忍毫秒级到秒级陈旧、单条数据不大、访问有明显热点的场景。反过来,强一致的资金余额、频繁变化的库存扣减、一次性的报表查询,放进去多半会带来一致性问题,收益却有限。

进程内缓存和集中式缓存经常一起用:极热的少量数据放进程内,几十毫秒过期;其余放 Redis。这叫两级缓存。它的代价是「什么时候让进程内那份失效」变得很难,通常只能靠很短的过期时间,别指望精确失效。

命中率与回源量怎么算

命中率等于命中次数除以总请求次数。它决定回源压力:回源 QPS 等于总 QPS 乘以未命中率。这两个数必须一起看,单看命中率会误导。命中率百分之九十听起来不错,但如果总 QPS 是十万,回源仍有一万。

我用本机 Node 做了一个按访问频次分布的模型:容量两千个键,过期时间六十秒,请求按真实系统的「少数热点、大量长尾」分布。结果是命中率 80.08%,在总请求约一千六百多每秒的情况下,回源约 332 QPS。这个数就是数据库要承接的额外读压力。

缓存容量 2000,TTL 60s:命中率 80.08%   回源 QPS 332

命中率不是越高越好。为了把命中率从八十提到九十五,往往要显著扩大容量或延长过期时间,前者增加内存成本,后者增加数据陈旧的风险。更合理的做法是先确认「回源量后端能不能接住」,再决定要不要继续优化。

还要区分「请求命中率」和「字节命中率」。大对象命中次数少但占带宽多,小对象相反。CDN 按字节算成本,缓存按对象数算容量,两者都要看。

穿透:查不存在的数据

穿透是指请求查一个根本不存在的键。缓存里没有,数据库里也没有,于是每次都要去数据库确认一遍,而确认完又没有东西可以缓存,下次同样的请求再来一遍。攻击者很容易利用这一点:拿一批随机 ID 持续请求,缓存永远不命中,压力全部落在数据库。

本机模型里,二十万次请求中有 79881 次查的是不存在的键,去重后是 76834 个不同键。不做任何处理,这 79881 次全部回源;给空结果也缓存一份短过期值,回源降到 76834 次(去重后的每个键只查一次);在前面加一个布隆过滤器,按百分之一误判率算,回源约 768 次。

不存在键请求: 79881 次,去重后 76834 个
无保护回源: 79881 次
空值缓存回源: 76834 次
布隆过滤器(1% 误判)回源: 约 768 次

空值缓存简单,但要注意过期时间要短,否则数据后来真的被创建了,用户会在一段时间内一直看到「不存在」。还要防止攻击者用大量不同的随机键把空值缓存撑满,所以空值缓存的键也要有统一前缀和容量上限。

布隆过滤器是一个位数组加热门哈希函数,能快速判断「这个键一定不存在」或「可能存在」。它只会误判「存在」,不会漏判,所以能挡掉绝大多数无效查询。代价是需要维护一份位数组,数据新增时要同步写入,删除很麻烦。它适合「键集合相对稳定、新增可预期」的场景。

最根本的办法还是在入口做参数校验和频率限制:ID 格式不对直接拒绝,同一来源短时间内大量空结果就限流。缓存层只能减少无效回源,挡不住有意的扫描。

击穿:一个热键同时失效

击穿和穿透只差一个字,但原因完全不同。击穿是「这个键存在、而且很热,但它过期的那一瞬间,很多请求同时发现没有,于是同时去重建」。重建通常要查数据库、组装数据、写回缓存,耗时几十毫秒;这段时间里所有并发请求都在等,数据库会瞬间收到成百上千个相同查询。

本机模型:一个热键过期后,一千个并发请求同时到达。不加协调,一千个请求全部回源,数据库收到一千次相同查询;加 single-flight(同一进程内只允许一个请求去重建,其余等待结果),回源只有一次。

热键过期后 1000 并发:
无锁回源     1000 次
single-flight   1 次

single-flight 的思路是「按 key 加锁,只有拿到锁的请求回源,其它请求等一小段时间后重试读缓存」。实现可以是进程内的锁,也可以是 Redis 的 SET NX 加短过期。进程内锁只能约束单个实例,多实例部署时仍会有「每个实例各回源一次」,但已经从一千次降到实例数量级,通常够用。

另一种做法是「逻辑过期」:缓存值里带一个过期时间字段,但不给键设真实过期。读到逻辑过期后,先返回旧值,同时异步触发一个重建任务。这样用户永远不会等重建,代价是会短暂读到旧数据。适合对实时性要求不高的详情页。

不要用「永不过期」来逃避击穿。永不过期的键会一直占内存,数据变了也不会更新,最终变成一套没人敢动的脏数据。击穿要正面解决,不能靠不设过期绕过去。

雪崩:一批键同时消失

雪崩是击穿的群体版本:大量键在同一时刻失效,或缓存实例整体不可用,导致回源量瞬间超过数据库承受能力。它不一定是「同一秒」,也可能是「同一分钟内集中过期」,效果一样。

本机模型把一批键的过期时间都设成六十秒:第 59 到 60 秒回源 0 次,第 60 到 61 秒回源 676 次。平时这些请求都被缓存挡住,数据库只承担少量回源;一到点,676 次回源集中打过去。

同一批 key 同时过期:
59-60s 回源 0 次
60-61s 回源 676 次

解法有三层。第一层是打散过期时间:在基础过期时间上加一个随机偏移,比如六十秒加零到三十秒的随机数,让失效点分散开。第二层是预热:发布或迁移后,先把热点数据批量写回缓存,再放流量进来。第三层是兜底:缓存整体不可用时,入口限流、返回旧值或降级页面,别让所有请求直接落到数据库。

还有一个常被忽略的点:缓存实例挂掉和「缓存里没数据」是两回事。前者要靠高可用(主从、哨兵、集群)和客户端熔断;后者要靠预热和回源限流。高可用不能替代预热,预热也不能替代高可用。

什么时候不该上缓存

数据强一致且每次读都要最新,比如账户余额、库存余量、订单状态,缓存只能做「短期展示」不能做「判断依据」。如果业务必须每次读库才能正确,加缓存只是把错误藏起来。

访问没有热点、每次查询的键都不同,比如按任意条件组合的报表查询。缓存命中率会很低,内存被大量一次性数据占满,淘汰频繁,反而拖慢。

写多读少。每次写都要让缓存失效,读的收益抵不过失效的复杂度和不一致风险。这种场景更适合优化数据库索引和查询,而不是加一层缓存。

团队没有能力处理「缓存和数据库不一致」。缓存带来的最终一致需要在业务上被接受,也需要有对账和修复手段。没有这些,缓存就是一个随机出现脏数据的地方。

不要为了「减轻数据库压力」给所有查询都加缓存。缓存只对「重复读同一份数据」有效。把缓存键设计成包含用户 ID、时间戳、随机数,等于每次都不同,命中率会接近零,还白占内存。

关键配置与用法样例

Redis 侧最重要的是内存上限和淘汰策略。不设上限,内存涨到机器极限会被系统杀掉;设了上限但策略不对,热数据会被冷数据挤掉。下面配置在本机实际生效,只是把上限调成 32MB 以便快速看到淘汰。

# redis.conf 片段(本机实测,maxmemory 调成 32mb)
maxmemory 4gb
maxmemory-policy allkeys-lfu
# 打开键空间通知,便于观察过期与淘汰(按需)
notify-keyspace-events Ex
# 慢查询阈值,单位微秒
slowlog-log-slower-than 10000
slowlog-max-len 128

allkeys-lfu 按访问频率淘汰,适合有明显热点的读缓存;allkeys-lru 按最近使用时间,适合访问分布比较均匀的场景;volatile-* 只淘汰设了过期时间的键,适合「一部分键必须常驻」的混合场景。策略选错,表现是内存满了但命中率一直掉。本机把上限设成 32MB 后灌入约 36MB 数据,键数停在 46505,被淘汰 13495 个,正是这个现象。

应用侧用「旁路缓存」模式:先读缓存,未命中读数据库,再写回缓存,并给过期时间加随机偏移。写路径先更新数据库,再删除缓存,不要更新缓存。为什么是这个顺序,下一篇组合方案会专门算账,这里先记住结论。

async function getProduct(id, now) {
  const key = `product:${id}`;
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);

  const row = await db.query('SELECT * FROM product WHERE id = $1', [id]);
  if (!row) {
    await redis.set(key, '__NULL__', 'EX', 30);   // 空值缓存,短过期
    return null;
  }
  const ttl = 60 + Math.floor(Math.random() * 30); // 打散过期
  await redis.set(key, JSON.stringify(row), 'EX', ttl);
  return row;
}

热键重建用 single-flight,键的粒度要细,别用一把全局锁把所有键的重建都串行化。

const inflight = new Map();

async function loadWithSingleFlight(key, loader) {
  if (inflight.has(key)) return inflight.get(key);
  const p = loader().finally(() => inflight.delete(key));
  inflight.set(key, p);
  return p;
}

怎么验证:命令与成功判据

下面命令在本机 Redis 5.0.14.1 上全部跑过,输出照录。

# 1. 看命中与未命中累计数
redis-cli info stats | grep -E 'keyspace_hits|keyspace_misses'

# 2. 看内存、淘汰与碎片
redis-cli info memory | grep -E 'used_memory_human|mem_fragmentation_ratio'
redis-cli info stats | grep evicted_keys

# 3. 找出大键(抽样,别在生产全量扫)
redis-cli --bigkeys

# 4. 看慢查询
redis-cli slowlog get 10

# 5. 观察某个键的剩余过期时间
redis-cli ttl product:1001
# 本机实际输出(Redis 5.0.14.1,端口 6381)
127.0.0.1:6381> PING
PONG
127.0.0.1:6381> SET user:1:name alice EX 60
OK
127.0.0.1:6381> TTL user:1:name
(integer) 60
127.0.0.1:6381> SETNX lock:order:1001 owner-a
(integer) 1
127.0.0.1:6381> EXPIRE lock:order:1001 10
(integer) 1
127.0.0.1:6381> TTL lock:order:1001
(integer) 10

127.0.0.1:6381> INFO memory
used_memory_human:31.00M
maxmemory_human:32.00M
maxmemory_policy:allkeys-lru
127.0.0.1:6381> INFO stats
evicted_keys:13495
expired_keys:2
keyspace_hits:2
keyspace_misses:0
127.0.0.1:6381> DBSIZE
(integer) 46505
# 灌入 60000 个 600 字节 value(约 36MB),内存封顶后开始淘汰

# redis-benchmark -c 50 -n 2000
SET: 7751.94 requests per second
GET: 37735.85 requests per second

成功判据:命中率与业务预期一致(比如读缓存稳定在八成以上);evicted_keys 增速平缓,不出现持续大量淘汰;mem_fragmentation_ratio 在 1.0 到 1.5 之间,明显偏高说明碎片多,偏低说明可能用了交换分区;慢查询里没有持续出现的业务命令;热点键的过期时间分散,不是同一分钟集中消失。

还要做一次「缓存清空演练」:在低峰期清掉一批键,观察回源 QPS 和数据库连接数的变化,确认限流和预热流程有效。这个演练比看监控更能暴露问题,因为平时缓存不会真的全空。

边界与代价

加缓存,就接受了「一段时间内数据可能旧」。这段窗口有多长、业务能不能忍,要在需求评审时写清楚,不能等线上出问题再讨论。不同数据可以有不同的容忍度,用一个统一过期时间是把所有风险取最大值。

缓存也会掩盖数据库的问题。查询没索引、SQL 写得低效,加了缓存后暂时看不出来,等缓存命中率下降或数据量变大,问题会以更猛烈的方式回来。缓存是止痛药,不是治疗。

运维上,Redis 不是「装了就完事」。要做持久化策略选择、主从与故障切换、内存监控、键命名规范、过期清理、在线扩容。单实例变成集群后,跨槽的多键操作、事务、Lua 脚本都会受限,这些限制要在设计键的时候就考虑。

成本上,内存比磁盘贵得多。把冷数据放在 Redis 里,等于用最贵的存储装最少访问的数据。定期分析访问频次,把长尾数据移出去,比一味加内存划算。

当天能自验的五个练习

一,写一个按访问频次分布的请求生成器,给一个固定容量的缓存加过期时间,统计命中率与回源量。成功判据:能说出「容量翻倍后命中率涨了多少、回源降了多少」,而不是只看到一条曲线。

二,复现雪崩:把一百个键的过期时间全设成同一秒,观察那一秒前后的回源次数。再把过期时间加随机偏移,重复一次。成功判据:尖峰被打散,回源在时间上分布得更均匀。

三,复现击穿:让一个热键过期,同时发一千个并发请求,统计回源次数。然后加 single-flight,再统计一次。成功判据:回源从千级降到个位数或实例数量级。

四,复现穿透:生成一批不存在的键持续请求,分别在不做保护、空值缓存、布隆过滤器三种情况下统计回源次数。成功判据:结果与本文的数量级一致,能解释每种方案的代价。

五,给本地 Redis(或任意缓存服务)接一个监控脚本,每分钟打印命中率、内存、淘汰数。跑一小时,观察命中率随时间和内存变化的趋势。成功判据:能指出命中率下降是被淘汰导致,还是请求分布变化导致。

和下一篇的关系

缓存解决的是「重复读」的问题,但有些工作本质上是「现在不做、等会儿再做」,比如发短信、生成报表、同步库存。这类工作要靠消息队列。下一篇讲 Kafka、RabbitMQ、RocketMQ 怎么选:它们各自假设什么、吞吐和延迟差在哪、什么时候用了反而是负担。

先把这一篇的三个词记住:穿透是查不存在的,击穿是一个热的没了,雪崩是一批同时没了。三种病,三种药,别混着治。