Skip to content

4.2-9 热点 key 解决方案与大 key 治理 ​

所属:04 数据存储 / 4.2 Redis 分级:A 状态:◐ 初稿 关联:4.2-1、4.2-2、4.2-5、4.2-6、4.2-8、4.2-10、4.2-12

  • 题型:排查 / 场景 / 治理

  • 一句话结论:热 key 是“流量集中”,大 key 是“体积/元素集中”,两者经常叠加成最坏情况。热 key 靠“本地缓存 + 副本/分片 + 限流降级 + 请求合并”分摊流量;大 key 靠“拆分、压缩、分页访问、异步删除、迁移前治理”控制单次操作成本。核心不是某一个技巧,而是 发现 → 定位 → 拆分/隔离 → 保护下游 → 防回归 的治理闭环。

  • 分层要点:

    1. 先分清热 key 和大 key:热 key 是单个 key 的 QPS 远高于平均,可能打满单核/单 slot;大 key 是 value 过大或集合元素过多,单次 HGETALL/SMEMBERS/LRANGE/DEL 就可能阻塞。热 key 不一定大,大 key 不一定热,但“热的大 key”最危险。
    2. 热 key 的危害:单分片/单节点 CPU 打满、网络带宽打满、慢查询、连接池耗尽、缓存击穿到 DB、Cluster 槽倾斜;如果是写热 key,还会形成单 key 锁竞争/单线程排队。热 key 的 QPS 可能不高但 value 大,也会造成带宽瓶颈。
    3. 热 key 发现:redis-cli --hotkeys 依赖 LFU(allkeys-lfu/volatile-lfu),通过 SCAN + OBJECT FREQ 找高频 key;没有 LFU 时可用 MONITOR(短时间、低峰、注意性能)、代理/客户端埋点、SLOWLOG(只覆盖慢命令,不可靠)、INFO commandstats(只到命令级)、抽样 SCAN + OBJECT FREQ。
    4. 热 key 读方案:本地缓存(Caffeine/Guava)扛住 top N 热读;Redis 副本 key(hot:{id}:{0..N})随机读分摊;Cluster 只读副本 + READONLY 分摊;请求合并/singleflight 防击穿;逻辑过期/互斥锁防缓存失效瞬间打爆 DB。
    5. 热 key 写方案:计数器拆成 N 个分片 INCR hot:counter:{id}:{0..N},读取时求和;写请求走 MQ 聚合/批量落库;对强一致写,用分片 + 版本/幂等 + 对账;不要对单 key 做高频 INCR/SET。
    6. 保护与降级:限流(令牌桶/滑动窗口)、熔断、降级返回旧值/默认值、隔离线程池/连接池;热点商品/秒杀场景预热、异步下单、队列削峰;保护 Redis 也保护 DB。
    7. 大 key 的危害:单次命令阻塞 Redis 单线程(HGETALL/SMEMBERS/LRANGE 0 -1/ZRANGE 0 -1)、网络带宽、客户端反序列化 CPU、DEL/过期阻塞、RDB fork/COW 内存膨胀、AOF 重写慢、主从全量同步/复制缓冲、Cluster 槽迁移卡住、内存倾斜/OOM。
    8. 大 key 治理:预防(key 设计、分页、TTL/归档、JSON→protobuf/压缩)→ 发现(--bigkeys/--memkeys/MEMORY USAGE/SCAN 抽样/离线 RDB 分析)→ 拆分(Hash 分桶、List 分块、Set/ZSet 分片、String 分块/压缩)→ 删除(UNLINK、HSCAN+HDEL 分批)→ 迁移(先拆再 reshard)→ 监控防回归。
  • 图/流程:

text
热 key 治理闭环:
  发现(--hotkeys / 代理 / 客户端 / 抽样)
    → 定位(QPS、带宽、CPU、慢查询、槽倾斜)
    → 分摊(本地缓存 / 副本 / 分片 / 副本读)
    → 保护(限流 / 熔断 / 降级 / 请求合并)
    → 复盘(阈值、告警、容量)
text
本地缓存 + Redis + DB:
  请求 → 本地缓存(top N 热 key)
        ├─ 命中 → 返回
        └─ 未命中 → Redis
              ├─ 命中 → 回填本地
              └─ 未命中 → singleflight/互斥 → DB
  一致性:短 TTL + pub/sub/MQ 失效 + 版本号
text
热 key 副本:
  hot:item:1000:0
  hot:item:1000:1
  ...
  hot:item:1000:N
  读:随机选一个副本
  写:更新所有副本 / 版本号 / 只读数据
text
计数器分片:
  INCR counter:item:1000:0
  INCR counter:item:1000:1
  ...
  读:SUM 所有分片
  写:MQ 聚合/批量落库 + 对账
text
大 key 拆分:
  Hash  → 按 field hash 分桶
  List  → 按时间/页码分块
  Set   → 按 member hash 分片
  ZSet  → 按 score 范围/member hash 分片
  String→ 压缩 / 分块 / 拆字段 / 换存储
text
大 key 删除:
  整个 key → UNLINK
  Hash → HSCAN + HDEL 分批
  Set  → SSCAN + SREM 分批
  ZSet → ZSCAN + ZREM 分批
  List → LTRIM / LPOP count 分批
text
Cluster 热 slot:
  热 key → 一个 slot → 一个 master
  副本读:READONLY + 客户端负载均衡
  拆分:副本 key 分散到不同 slot
  注意:hash tag 会把 key 绑在同一 slot,可能加剧热点
  • 版本/源码锚点:

    • Redis 4.0:LFU、OBJECT FREQ、UNLINK、lazyfree、MEMORY USAGE;redis-cli --hotkeys/--bigkeys/--memkeys。
    • Redis 6.0:多线程 IO、ACL、TLS;6.2:LPOP key count、GETEX、HRANDFIELD。
    • Redis 7.0:CLUSTER SHARDS、sharded pub/sub、maxmemory-clients。
    • 关键命令:OBJECT FREQ、MEMORY USAGE、SCAN、HSCAN、SSCAN、ZSCAN、UNLINK、CLUSTER GETKEYSINSLOT。
    • 源码/工具:src/object.c(OBJECT FREQ)、src/evict.c(LFU)、src/t_hash.c/t_set.c/t_zset.c/t_list.c(大 key 操作)、redis-cli 的 --hotkeys/--bigkeys/--memkeys、redis-rdb-tools。
  • 热 key vs 大 key:

维度热 key大 key
本质流量集中体积/元素集中
典型明星八卦、秒杀商品、热门榜单大 JSON、百万 field 的 Hash、百万 member 的 ZSet
危害单核/单槽打满、带宽、击穿单命令阻塞、删除/迁移/持久化抖动
发现--hotkeys、代理/客户端埋点、抽样--bigkeys、--memkeys、MEMORY USAGE
治理本地缓存、副本、分片、限流拆分、压缩、分页、异步删除
叠加热的大 key 最危险先拆大 key,再分摊热
  • 热 key 发现工具:
工具原理优点局限
redis-cli --hotkeysSCAN + OBJECT FREQ直接找高频 key需 LFU;采样可能漏
MONITOR实时命令流能看到真实访问性能开销大,不能长期开
SLOWLOG慢命令简单热 key 不一定慢
INFO commandstats命令级统计低开销看不到具体 key
代理/客户端埋点统计 key 访问贴近业务需改造/采样
SCAN + OBJECT FREQ抽样灵活需 LFU、遍历成本
redis-faina解析 MONITOR聚合热点同样有 MONITOR 开销
  • 热 key 解决方案:
方案适用优点代价
本地缓存读多、可容忍短时旧值无网络、抗热一致性/内存/多实例
副本 key只读热点分摊读写放大/一致性
Cluster 只读副本读多、可旧读分摊单节点副本延迟/READONLY
计数器分片写热点分摊写聚合/对账
MQ 聚合/批量写热点、可异步削峰延迟/复杂度
请求合并/singleflight缓存击穿保护 DB等待/超时
逻辑过期/互斥锁热点失效防击穿实现复杂
限流/熔断/降级突发流量保护系统业务有损
预热/离线计算可预测热点主动需运营/计算
  • 大 key 判断(经验阈值):
类型经验阈值说明
String>10KB 关注,>1MB 高风险按 QPS/带宽调整
Hashfield >5000/10000HLEN
List元素 >5000/10000LLEN
Set元素 >5000/10000SCARD
ZSet元素 >5000/10000ZCARD
Stream长度/内存大XLEN、XINFO STREAM
  • 大 key 发现:
方法原理注意
redis-cli --bigkeysSCAN + TYPE + STRLEN/LLEN/HLEN/SCARD/ZCARD找每类型最大,低峰执行
redis-cli --memkeysSCAN + MEMORY USAGE更贴近内存,可能慢
MEMORY USAGE key [SAMPLES]估算 key 内存抽样,非精确
STRLEN/HLEN/LLEN/SCARD/ZCARD元素/长度快速判断
OBJECT ENCODING编码判断 listpack/hashtable
SCAN 抽样自定义阈值避免 KEYS *
离线 RDB 分析解析 RDB不影响线上,需工具
SLOWLOG/LATENCY慢命令/延迟只覆盖已发生的问题
  • 大 key 拆分模式:
类型拆分方式查询代价
Hash按 field hash 分桶 hash:{id}:{bucket}需聚合/按桶查
List按时间/页码分块 list:{id}:{page}跨块分页
Set按 member hash 分片 set:{id}:{shard}并集/逐个判断
ZSet按 score 范围/member hash 分片跨片归并 TopN
String压缩、分块、拆字段、换存储组装/解压
Stream按时间窗口 XTRIM/分表跨窗口查询
  • 大 key 删除:
类型方式注意
整个 keyUNLINK key后台释放,4.0+
HashHSCAN + HDEL 分批每批 100–1000,sleep
SetSSCAN + SREM 分批同上
ZSetZSCAN + ZREM 分批同上
ListLTRIM / LPOP key count分批
StreamXTRIM按长度/时间
通用lazyfree-lazy-user-del yesDEL 后台化
  • 监控与防回归:
指标作用告警
单 key QPS/带宽热 key超均值 N 倍
单分片/单 slot CPU热槽单节点显著高
OBJECT FREQLFU 频率TopN
MEMORY USAGE/--bigkeys大 key超阈值
SLOWLOG/LATENCY慢命令/抖动P99
evicted_keys/命中率容量命中率下降
复制延迟/槽迁移大 key 影响延迟/超时
客户端反序列化耗时大 value超时
  • 深挖点(面试官常追的 6 个):

    1. --hotkeys 为什么依赖 LFU:它通过 SCAN 遍历 key,再用 OBJECT FREQ 读 LFU 计数器排序;如果 maxmemory-policy 不是 allkeys-lfu/volatile-lfu,OBJECT FREQ 不可用,工具会报错。没有 LFU 时只能用 MONITOR/代理/客户端埋点/抽样,或者临时开 LFU(影响淘汰行为,需谨慎)。
    2. 本地缓存的一致性:本地缓存抗热最有效,但多实例更新会不一致。常用“短 TTL + 发布订阅/MQ 失效 + 版本号”组合;强一致场景不适合本地缓存,或只缓存只读/可容忍旧值的数据。本地缓存还要控制容量和淘汰,避免把热 key 变成应用 OOM。
    3. 热 key 副本 vs 分片:副本 key 是同一份数据复制 N 份,读随机分摊,适合只读;写要更新所有副本,容易不一致。分片是把逻辑 key 拆成 N 个子 key(如计数器),读写都分摊,但读取要聚合、写入要处理部分失败。两者都别用 hash tag 把副本绑回同一 slot,否则热槽没解决。
    4. 大 key 为什么阻塞:Redis 单线程执行命令,HGETALL 百万 field、SMEMBERS 百万成员、DEL 大 key 都要一次性遍历/释放;网络传输和客户端反序列化也会放大。RDB fork 后写大 key 触发 COW 复制页,内存可能翻倍;主从全量同步和 Cluster MIGRATE 也会被大 key 拖住。
    5. 大 key 拆分后的查询代价:拆 Hash 后按 field 查要定位桶,全量统计要遍历所有桶;拆 ZSet 后 TopN 要跨片归并;拆 List 后分页要跨块。拆分不是免费,必须把“读模式”一起设计,否则只是把单 key 阻塞换成 N 次网络往返。能用 pipeline/并行查就并行,但要控制连接数和尾延迟。
    6. 删除和迁移是事故高发点:DEL 大 key 同步释放会卡主线程,优先 UNLINK;集合用 HSCAN/SSCAN/ZSCAN 分批删,控制每批大小和 sleep。Cluster 迁移大 key 时 MIGRATE 序列化/传输会超时,甚至触发 failover;要先拆 key 再 reshard,低峰执行并监控 cluster-node-timeout。
  • 追问链:

    1. 什么是热 key? → 单 key QPS 远高于平均,流量集中。
    2. 热 key 有什么危害? → 单核/单槽打满、带宽、慢查询、击穿 DB、槽倾斜。
    3. 怎么发现热 key? → --hotkeys、MONITOR、代理/客户端埋点、SLOWLOG、抽样。
    4. --hotkeys 原理? → SCAN + OBJECT FREQ,按 LFU 频率排序。
    5. --hotkeys 前提? → LFU 策略(allkeys-lfu/volatile-lfu)。
    6. 没有 LFU 怎么发现? → MONITOR 短时、代理/客户端埋点、抽样、临时开 LFU。
    7. MONITOR 能生产长期开吗? → 不能,性能开销大。
    8. SLOWLOG 能发现热 key 吗? → 不一定,热 key 命令可能很快。
    9. 热 key 读怎么优化? → 本地缓存、副本 key、只读副本、请求合并。
    10. 本地缓存怎么保证一致性? → 短 TTL、pub/sub/MQ 失效、版本号;接受最终一致。
    11. 副本 key 怎么用? → 同一 value 复制 N 份,读随机,写全量更新。
    12. 副本 key 有什么问题? → 写放大、一致性、hash tag 可能仍热槽。
    13. 热 key 写怎么优化? → 计数器分片、MQ 聚合、批量落库、异步。
    14. 计数器分片怎么读? → 读所有分片求和;注意部分失败/对账。
    15. 秒杀热点怎么处理? → 预热、限流、队列、异步下单、库存分片、降级。
    16. 缓存击穿怎么防? → 互斥锁/逻辑过期/singleflight/热点永不过期。
    17. 逻辑过期是什么? → value 带过期时间,异步刷新,先返回旧值。
    18. 请求合并怎么做? → singleflight/CompletableFuture,同 key 只回源一次。
    19. 热 key 在 Cluster 怎么分摊? → 只读副本、副本 key 分散 slot、拆分;注意 hash tag。
    20. 热 key 和大 key 关系? → 热的大 key 最危险;先拆大 key 再分摊热。
    21. 什么是大 key? → value 大或集合元素多,单次操作成本高。
    22. 大 key 有什么危害? → 阻塞、带宽、删除/过期、fork/COW、复制、迁移、OOM。
    23. 怎么发现大 key? → --bigkeys、--memkeys、MEMORY USAGE、SCAN 抽样、RDB 分析。
    24. --bigkeys 原理? → SCAN + TYPE + 各类型长度命令,找最大。
    25. --memkeys 原理? → SCAN + MEMORY USAGE,按内存排序。
    26. MEMORY USAGE 精确吗? → 估算/抽样,看趋势够用。
    27. 大 key 阈值多少? → 经验值,String 10KB/1MB,集合 5000/10000,按业务调。
    28. Hash 大 key 怎么拆? → 按 field hash 分桶,查询按桶聚合。
    29. List 大 key 怎么拆? → 按时间/页码分块,分页跨块。
    30. ZSet 大 key 怎么拆? → 按 score 范围/member hash 分片,TopN 归并。
    31. String 大 JSON 怎么治理? → 压缩、protobuf、拆字段、分块、换存储。
    32. 大 key 怎么删? → UNLINK;集合 HSCAN/SSCAN/ZSCAN 分批删。
    33. UNLINK 和 DEL 区别? → UNLINK 后台释放,DEL 同步。
    34. 大 key 过期会卡吗? → 会,开 lazyfree-lazy-expire/分批。
    35. 大 key 对持久化影响? → fork/COW 内存膨胀、RDB/AOF 重写慢。
    36. 大 key 对复制影响? → 全量同步/复制缓冲/从库加载慢。
    37. 大 key 对 Cluster 影响? → 槽迁移 MIGRATE 阻塞/超时、内存倾斜。
    38. 大 key 迁移怎么做? → 先拆、低峰、监控 cluster-node-timeout、必要时 MIGRATE 分批。
    39. 怎么防大 key? → key 设计评审、分页、TTL/归档、压缩、监控阈值。
    40. 大 key 和慢查询关系? → 大 key 操作常慢,但慢查询不一定大 key。
    41. KEYS * 能找大 key 吗? → 不能,阻塞且不返回大小;用 SCAN/--bigkeys。
    42. HGETALL 大 Hash 怎么替代? → HSCAN 分页、HMGET 指定字段。
    43. SMEMBERS 大 Set 怎么替代? → SSCAN、SRANDMEMBER/SISMEMBER。
    44. 治理流程? → 发现 → 评估 → 拆分/压缩 → 删除/迁移 → 监控防回归。
    45. 线上事故怎么复盘? → 热 key/大 key 定位、保护下游、拆分、限流、预案。
  • 生产案例/取舍(示例,替换成你的项目):

    • 明星八卦热 key,QPS 打满单分片;本地缓存 + 副本 key + 限流,Redis 恢复。
    • 秒杀商品库存单 key INCR 热写;库存分片 + MQ 异步下单 + 令牌桶。
    • 热门榜单 ZSet 百万 member,ZRANGE 0 -1 慢;分片 + 只取 TopN。
    • 大 Hash 100 万 field,HGETALL 阻塞;按 field hash 分桶 + HMGET。
    • 大 List 当队列,LRANGE 0 -1 慢;按时间分块 + 分页。
    • 大 key DEL 卡主线程;改 UNLINK + HSCAN/HDEL 分批。
    • Cluster 迁移大 key 超时;先拆分再 reshard,低峰执行。
    • --hotkeys 报错,因为策略是 allkeys-lru;临时切 LFU 采样后恢复。
    • 本地缓存与 Redis 不一致;短 TTL + MQ 失效 + 版本号,接受最终一致。
    • 取舍:本地缓存换低延迟,代价是一致性/内存;副本换读吞吐,代价是写放大;分片换分摊,代价是聚合/对账;限流换稳定,代价是业务有损;拆大 key 换低延迟,代价是查询复杂度。
  • 易错点:

    • 认为热 key 一定慢。
    • 认为大 key 一定热。
    • 认为 SLOWLOG 能发现所有热 key。
    • 生产长期开 MONITOR。
    • 认为 --hotkeys 不需要 LFU。
    • 认为本地缓存强一致。
    • 副本 key 用 hash tag 绑同一 slot。
    • 计数器分片后忘记聚合/对账。
    • 热 key 只加机器不拆 key。
    • 忽略热 key 写放大。
    • 认为大 key 只影响内存。
    • 用 KEYS * 找大 key。
    • 认为 --bigkeys 找出所有大 key(只找每类型最大)。
    • 认为 MEMORY USAGE 精确。
    • 大 key 直接 DEL。
    • 集合大 key 用 HGETALL/SMEMBERS/ZRANGE 0 -1。
    • 拆分后不做跨桶聚合/分页。
    • 大 key 未拆就做 Cluster 迁移。
    • 忽略 fork/COW/复制缓冲。
    • 忽略客户端反序列化/网络带宽。
    • 不做监控/阈值/防回归。
    • 认为加内存能解决大 key。
  • 30 秒口述稿:

热 key 是流量集中,大 key 是体积集中,热的大 key 最危险。热 key 用 --hotkeys(LFU)或代理/客户端埋点发现,读靠本地缓存、副本 key、只读副本、请求合并,写靠计数器分片、MQ 聚合,外加限流降级。大 key 用 --bigkeys/--memkeys/MEMORY USAGE 发现,治理靠 Hash 分桶、List 分块、Set/ZSet 分片、String 压缩拆分,删除用 UNLINK 或 HSCAN/SSCAN/ZSCAN 分批,Cluster 先拆再迁移。核心是发现、拆分、保护下游、监控防回归。

  • 3 分钟展开顺序:结论(热 vs 大)→ 热 key 危害/发现 → 读方案(本地缓存/副本/只读副本)→ 写方案(分片/异步)→ 保护(限流/击穿/降级)→ 大 key 危害/发现 → 拆分模式 → 删除/迁移 → 监控/案例/取舍。