周三下午,本来是例行的一次压测。我们准备下周上线一个新活动,想先验证一下并发能力。压测脚本用的是 JMeter,目标并发 2000。

结果压测跑到第三分钟,监控告警开始疯狂弹窗——接口响应时间从 80ms 涨到 3 秒,接着是 12 秒,然后是大量 504。

我盯着屏幕,看着那条曲线几乎是垂直往上冲,心里一沉:这不是压测,这是把线上环境打崩了。

后来的两天,我们把这个问题彻底挖了一遍。今天把它写下来,因为这不是一个单纯的"压测参数设错了"的问题,而是一个很经典的、几乎所有高并发系统都会遇到的坑——Redis 热点 Key。

一、故障现场

先把现象说清楚。

症状一:接口大面积超时

主接口(商品详情页)的平均响应时间从 80ms 飙升到 3 秒以上,P99 直接到 12 秒。超过一半的请求返回 504 网关超时。

症状二:Redis 单节点 CPU 打满

监控上 Redis 有一个节点的 CPU 使用率跑到了 100%,并且持续了将近五分钟。其他节点都在 30% 以下,很闲。

症状三:连接数暴涨

Redis 的 client 连接数从 200 多暴涨到 3000 以上,触发了最大连接数限制。应用侧的连接池全部被打满,后面的请求只能排队。

症状四:慢查询日志

Redis 的慢查询日志里出现了大量 20ms 以上的操作,全部集中在几个特定的 key 上。

这四个现象放在一起,指向已经非常明确了:所有流量都砸在了同一个 key 上,而那个 key 所在的节点扛不住。

二、为什么会有热点 Key

先说清楚是什么。

我们的商品详情页,缓存结构是这样的:

KEY: product:detail:{product_id}
VALUE: 商品详情 JSON(约 30KB)

平常没问题,因为商品有几万个,流量分散在几万个 key 上,每个 key 的 QPS 都不高。

但这次压测不一样。压测脚本为了简单,只用了 10 个商品 来做测试。2000 并发全部打在这 10 个商品上,就等于每个 key 承担了 200 QPS。

而更糟的是:这 2000 个并发请求里,有大量请求在同一个时间窗口内同时发现缓存未命中,于是同时去查数据库、同时回填缓存。

这就是经典的三个问题叠加:

1. 热点 Key —— 大量请求集中访问同一个 key,单个 Redis 节点(key 在集群里只落在一个 slot、一个节点)承受了全部压力。

2. 缓存击穿 —— 单个 key 失效的瞬间,大量请求同时穿透到数据库。

3. 缓存雪崩的前兆 —— 如果这 10 个 key 是在同一时间过期的,就会在那一瞬间形成对数据库的集中冲击。

而我们的实际情况是:三个问题同时发生了,因为压测时 key 少、并发高、过期时间又刚好撞在一起。

三、逐层排查

压测中止之后,我们开始一层一层地查。

第一步:确认是哪个 key

Redis 自带的 SLOWLOG GET 能看到慢操作的 key,但那只是抽样。更直接的办法是用 redis-cli --hotkeys(需要开启 LFU 淘汰策略)或者 redis-cli --bigkeys。

我们直接查了业务侧的监控——因为我们给每个缓存 key 都打了前缀标签,能看到每个前缀的 QPS。一查就出来了:product:detail:* 这个前缀的 QPS 峰值到了 1800,而平时是 60。

再看具体的 key 分布:前 10 个商品占了 92% 的请求量。这就是典型的热点。

第二步:看节点负载

我们的 Redis 是 3 主 3 从的集群。查了下 key 的 slot 分布,发现这 10 个商品刚好落在了同一个节点上(因为它们 ID 是连续的,CRC16 计算的 slot 也接近)。

所以整个集群 6 个节点的资源,实际上只有 1 个节点在干活。这就是"热点 Key 在集群里更危险"的原因——你扩了机器,但热点没法被分摊。

第三步:看 key 的大小

这个也很关键。查了一下,单个商品的详情 JSON 是 30KB。

30KB 的单次读取,在 200 QPS 下就是每秒 6MB 的网络传输;在网络带宽和序列化上都成了瓶颈。而且大的 value 会拖慢 Redis 内部的单线程处理——Redis 是单线程的,一个大 key 的读取会阻塞其他请求。

这是这次故障里的隐藏炸弹。如果 key 只有 3KB,可能还不至于崩,30KB 就雪上加霜了。

第四步:看是否发生了击穿

查数据库的 QPS 曲线——在缓存失效的那个时间点,数据库 QPS 从 200 暴涨到 1600,慢查询数量同步暴涨。

确认了:击穿发生了。因为我们在缓存失效时没有任何"单飞"保护,所有请求都直接冲向了数据库。

四、解决方案

找到原因之后,我们按严重程度排了优先级,一项一项改。

方案一:拆分大 key(解决体积问题)

30KB 一个大 value 太浪费。我们把它拆成几个小 key:

product:base:{id}       -> 基础信息(标题、价格、类目) 约 2KB
product:detail:{id}     -> 详情描述(富文本、参数)     约 15KB
product:sku:{id}        -> SKU 列表                      约 8KB
product:stock:{id}      -> 库存(单独高频更新)          约 1KB

详情页只加载它真正需要的部分。列表页只读 base,详情页再按需读取 detail 和 sku。

这一改,单个 key 的读取开销降低了 60% 以上。而且库存单独拆出来之后,高频的库存查询也不会把整个详情缓存拖下水。

方案二:热点 Key 本地缓存(解决集中访问)

这是最核心的一招。

对于已知的热点数据(比如首页推荐商品、活动商品),我们在应用进程内加一层本地缓存(用的是进程内的 LRU,不是 Redis)。

读取路径变成:进程内缓存 → Redis → 数据库。

进程内缓存的过期时间设得很短(比如 5 秒),保证数据不会太旧;但它能挡住绝大部分瞬时并发的重复读。如果 2000 个并发里,同一秒内有 500 个请求读同一个商品,那第一个请求读 Redis,后面 499 个直接读本地内存。

Redis 的压力瞬间降了一个数量级。

代价是:多台服务器的本地缓存之间有时间差(最长 5 秒),数据可能短暂不一致。对我们这个场景(商品详情,价格变动频率很低)是可以接受的。如果是库存这种强一致场景,就不能这么干,得走别的方案。

方案三:缓存击穿的"单飞"保护

缓存未命中时,不能所有请求都去查数据库。得加锁,只放一个请求进去。

我们的实现是:

1. 读缓存,命中直接返回
2. 未命中,尝试 SET key_lock NX EX 5(抢占锁)
3. 抢到锁的请求:查数据库 → 回填缓存 → 释放锁
4. 没抢到锁的请求:短暂 sleep(20ms)后重试读缓存
5. 重试 3 次还没读到,就直接返回兜底数据(降级)

这里有个坑:锁一定要设过期时间,且释放锁要用 Lua 脚本比对 value,避免误删别人的锁。我们第一版就写错了,锁释放时直接 DEL,结果把别人刚抢到的锁给删了。

第二个坑:sleep 的时间和重试次数要调。sleep 太长会让请求堆积,太短会浪费 CPU。我们试了 20ms × 3 次,效果比较好。

方案四:过期时间打散

缓存雪崩的根源是"同时过期"。解决办法很简单:给过期时间加随机扰动。

// 原来是:统一 30 分钟
$expire = 1800;

// 改成:30 分钟 ± 随机 5 分钟
$expire = 1800 + rand(-300, 300);

就这么一行代码,把一个整点的"雪崩"变成了平滑分布的失效曲线。

方案五:热点识别自动化

上面几个方案都是"事后补"。但热点是在变的——今天的热点商品,明天可能就冷了;一个新活动上线,瞬间就会产生新的热点。

所以我们加了一个小的热点识别机制:

在应用层对每个 key 做访问计数(用本地计数器,每 10 秒上报一次),当某个 key 在 10 秒内的访问量超过阈值(比如 500),就自动把它加入"热点名单",后续该 key 走本地缓存路径。

这样热点不需要人工配置,系统自己会认出来。成本不高,效果很明显。

五、改造后的压测结果

改动上线之后,我们重跑了同样的压测。参数没变,还是 2000 并发 + 10 个商品。

指标改造前改造后
平均响应时间3.2 秒42ms
P99 响应时间12 秒180ms
Redis 单节点 CPU100%18%
Redis 连接数3000+240
数据库 QPS 峰值1600210
504 错误率52%0%

Redis 的单节点 CPU 从打满降到 18%,数据库 QPS 几乎没涨。这说明绝大部分请求都被本地缓存挡住了,根本没到 Redis。

六、几点反思

第一,这次事故的根因其实在压测设计。

按理说压测应该用真实的数据分布,但我们为了"省事",只用了 10 个商品。这个偷懒导致了两个后果:一是压出了我们平时看不见的问题(好事),二是把线上环境打崩了(坏事)。

如果重来一次,我会在压测环境而不是生产环境做这件事。生产环境的压测,不管怎么说都太冒险了。

第二,Redis 集群不等于万能。

很多人以为"上了集群就解决了性能问题"。但集群解决的是"总量压力",不解决"单点热点"。如果所有请求都指向同一个 key,你集群再大也没用。这点是我们原来认识上的盲区。

第三,大 key 是隐形炸弹。

30KB 的 value 在平时完全看不出问题,一旦并发上来,它就成了压垮骆驼的那根稻草。这次排查完之后,我们把全站超过 10KB 的 key 全部做了一次体检,发现还有几个隐藏的大 key(有的是历史遗留的、内容长达 100KB 的富文本缓存)。

第四,缓存三件套(穿透、击穿、雪崩)不是理论题。

这三个词在书上看过很多次,总觉得是"极端场景"。这次真实打出来了,才知道它们是日常运维中随时可能踩到的东西。而且它们会叠加发生——不是单独一个,而是"热点 + 击穿 + 雪崩"同时上演。

第五,兜底比优化更重要。

这次真正救了我们的,不是性能优化,而是"降级兜底"——在重试 3 次还读不到缓存时,直接返回一份预置的兜底数据(比如商品的静态基础信息)。

性能再好的系统也会有极限。当极限到来的时候,能不能"优雅地慢"而不是"彻底崩掉",这才是一个系统真正成熟的地方。

写在最后

这次压测之后,我改了一个习惯:每次要压一个系统之前,先想清楚"最坏会怎样"。

不是想"能撑住多少并发",而是想"如果撑不住,会影响到谁、能不能拦住、怎么恢复"。这个念头帮我们在后半程避免了好几次冲动操作。

另外还有个小收获:这次排查让我重新读了一遍 Redis 的官方文档,尤其是单线程模型、LFU/LRU、集群 slot 分配这几块。有些东西以前是靠印象在做,这次对着文档看了一遍,才发现好几个理解是有偏差的。

技术债不只是代码写得乱,也包括"以为自己懂了但其实没懂"。这种债不会自己还,得靠一次真正的故障来催。