知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 48 - Redis 大 Key 问题排查与解决 > 导读:一个 800MB 的 Hash Key,能让一次 `DEL` 阻塞 Redis 两秒、把整个集群的请求拖垮。本文讲清大 Key 的判定标准、三种发现手段(含生产推荐的 RDB 离线分析)、三种拆分方案和安全的删除方式。 ## 一、先建立全局认知 ### Q:多大的 Key 才算"大 Key"? A:Redis 官方没有硬性定义,工程上通常用这组经验值: - String 类型:value > 10KB - Hash/Set/ZSet/List:元素数量 > 5000 或总大小 > 10MB 之所以是"经验值"而不是精确阈值,是因为危害取决于**访问方式**:一个 1MB 的 String 每次只 `GET` 全量返回,问题不大;而一个 5000 元素的 Hash 被 `HGETALL` 全量拉取,就会阻塞主线程。 ### Q:大 Key 会引起哪些连锁故障? A:一次真实故障的表现是这样的: ``` 1. 某个节点内存使用率远高于其他节点(数据倾斜) 2. 执行 DEL 某个 Key 时,Redis 阻塞了 2 秒,导致大量请求超时 3. 主从同步延迟增大,从节点频繁断开重连 4. 慢查询日志中频繁出现 HGETALL、SMEMBERS 等命令 排查发现:一个 Hash Key 存了 500 万个 field(用户签到记录),大小 800MB ``` 这四条现象正好对应大 Key 的四种危害: | 现象 | 根因 | |------|------| | 单节点内存倾斜 | 集群按 slot 分配,大 Key 所在的节点内存远高于其他节点 | | DEL 阻塞 2 秒 | Redis 是单线程处理命令,释放 800MB 内存阻塞了所有请求 | | 主从延迟 | 大 Key 的写命令产生大量同步数据,从节点处理不过来 | | 慢查询频繁 | `HGETALL`、`SMEMBERS` 这类全量命令搬移大量数据 |  [编辑 Excalidraw 源图](/images/java-interview-copy/online-troubleshoot/48-redis-bigkey-redis-bigkey-governance-flow-diagram.excalidraw) **"DEL 阻塞 2 秒"这条最能说明 Redis 的模型**:它是单线程处理命令的,删除一个 800MB 的 Key 意味着在主线程上做几百万次释放操作,期间所有其他命令排队等待——这跟"删除很快"的直觉正好相反。 ### Q:大 Key 为什么会导致主从同步延迟? A:Redis 主从同步是把写命令传播到从节点。大 Key 的写操作(如 `HSET` 500 万个 field)会生成大量的同步数据,从节点处理不过来就会延迟。另外,大 Key 过期时主节点发送 `DEL` 命令,从节点执行 `DEL` 也会阻塞。 ### Q:Redis Cluster 中大 Key 还会带来什么问题? A:数据倾斜。Redis Cluster 按 Key 分配到不同 slot,大 Key 所在的 slot 对应的节点内存和流量远高于其他节点。迁移 slot 时大 Key 也会导致迁移超时失败。 这也意味着**大 Key 是扩容时的隐形障碍**:平时只表现为"某个节点特别忙",一旦要做 slot 迁移或节点扩缩容,就会直接卡住。 ## 二、理解核心机制 ### Q:怎么发现线上的大 Key? A:三种手段,各有适用场景: **方法一:`redis-cli --bigkeys`(快速扫描)** ```bash # 扫描所有 Key,找出每种类型最大的 Key redis-cli --bigkeys -i 0.1 # -i 0.1 表示每扫描 100 个 Key 休眠 0.1 秒,降低对线上的影响 # 输出示例: # [00.00%] Biggest string found so far 'user:avatar:10086' with 512000 bytes # [00.00%] Biggest hash found so far 'user:checkin:2024' with 5000000 fields # [00.00%] Biggest set found so far 'product:fans:1001' with 200000 members ``` 缺点:只能找到每种类型最大的 1 个 Key,可能遗漏。 **方法二:`SCAN` + `MEMORY USAGE`(精确但侵入)** ```java // 遍历所有 Key,逐个检查大小 public List<BigKeyInfo> scanBigKeys(int threshold) { List<BigKeyInfo> bigKeys = new ArrayList<>(); ScanOptions options = ScanOptions.scanOptions().count(100).build(); try (Cursor<byte[]> cursor = redis.getConnectionFactory() .getConnection().scan(options)) { while (cursor.hasNext()) { String key = new String(cursor.next()); // MEMORY USAGE 返回 Key 占用的字节数 Long bytes = redis.execute((RedisCallback<Long>) conn -> conn.memoryUsage(key.getBytes())); if (bytes != null && bytes > threshold) { bigKeys.add(new BigKeyInfo(key, bytes, redis.type(key))); } } } return bigKeys; } ``` **方法三:RDB 离线分析(生产推荐)** ```bash # 用 rdb-tools 分析 RDB 文件,不影响线上 # 安装:pip install rdbtools rdb -c memory dump.rdb --bytes 10240 -f bigkeys.csv # 导出所有 > 10KB 的 Key 到 CSV 文件 # 或用 redis-rdb-tools 的在线版 redis-memory-for-key -s localhost -p 6379 user:checkin:2024 ``` > 三者的取舍:`--bigkeys` 快但只报"每种类型最大的一个";`SCAN` + `MEMORY USAGE` 精确,但会遍历全库、对线上有压力(尤其 `MEMORY USAGE` 是 O(N) 操作);RDB 离线分析**完全不影响线上**,可以做全量精确统计——所以生产环境做定期巡检时,优先选第三种。唯一的代价是需要拿到 RDB 文件(可从从节点上取)。 ### Q:为什么 `DEL` 大 Key 会阻塞 Redis? A:因为 Redis 处理命令是**单线程**的,`DEL` 一个包含几百万个 field 的 Hash,需要在这一个命令里完成所有的元素释放,期间无法处理其他任何请求。 理解这一点后,"安全删除"的三种方案就顺理成章了:要么把释放挪到后台线程(`UNLINK`),要么把一次大删除拆成多次小删除(分批 `SCAN` + `HDEL`),要么让服务器自动对这类删除做异步化(`lazyfree`)。 ## 三、放进真实场景 ### Q:发现大 Key 之后,怎么拆分? A:按数据类型选择拆分维度。 **场景一:大 Hash 拆分**——按 field 取模分桶: ```java // 原始:一个 Hash 存 500 万用户签到记录 // Key: user:checkin:2024 // Field: userId Value: checkinDays // 拆分:按 userId 取模分成 100 个小 Hash public class CheckinService { private static final int BUCKET_COUNT = 100; private String getKey(Long userId) { int bucket = (int) (userId % BUCKET_COUNT); return "user:checkin:2024:" + bucket; // user:checkin:2024:0, user:checkin:2024:1, ... user:checkin:2024:99 } public void checkin(Long userId) { String key = getKey(userId); redis.opsForHash().increment(key, userId.toString(), 1); } public Integer getCheckinDays(Long userId) { String key = getKey(userId); Object val = redis.opsForHash().get(key, userId.toString()); return val == null ? 0 : Integer.parseInt(val.toString()); } } ``` 分桶数(这里是 100)决定了单个 Key 的规模上限:500 万 ÷ 100 = 每桶 5 万个 field,从 800MB 降到 8MB 级别。注意分桶后**原来需要跨桶的操作都做不了了**(比如统计"总签到人数"必须遍历 100 个桶),这是拆分必然付出的代价。 **场景二:大 List 拆分**——按时间或序号分段: ```java // 原始:一个 List 存 100 万条消息 // 拆分:按时间或序号分段 public class MessageService { private static final int PAGE_SIZE = 1000; // 写入时按分段存储 public void addMessage(Long userId, String message) { String countKey = "msg:count:" + userId; Long count = redis.opsForValue().increment(countKey); int segment = (int) ((count - 1) / PAGE_SIZE); String listKey = "msg:" + userId + ":" + segment; redis.opsForList().rightPush(listKey, message); } // 读取指定分段 public List<String> getMessages(Long userId, int segment) { String listKey = "msg:" + userId + ":" + segment; return redis.opsForList().range(listKey, 0, -1); } } ``` 这种分段天然适合**按页读取**的消息列表场景:第 N 页就是第 N 段,读写都是 O(1) 定位。 **场景三:大 String 压缩**: ```java // 大 JSON 字符串,压缩后存储 public class CompressService { public void set(String key, Object value) { String json = JSON.toJSONString(value); byte[] compressed = compress(json.getBytes(StandardCharsets.UTF_8)); redis.opsForValue().set(key.getBytes(), compressed); } public <T> T get(String key, Class<T> clazz) { byte[] compressed = redis.opsForValue().get(key.getBytes()); if (compressed == null) return null; byte[] decompressed = decompress(compressed); return JSON.parseObject(new String(decompressed), clazz); } private byte[] compress(byte[] data) { // 使用 GZIP 或 Snappy 压缩 Deflater deflater = new Deflater(); deflater.setInput(data); deflater.finish(); ByteArrayOutputStream bos = new ByteArrayOutputStream(); byte[] buffer = new byte[1024]; while (!deflater.finished()) { int count = deflater.deflate(buffer); bos.write(buffer, 0, count); } return bos.toByteArray(); } } ``` JSON 文本的压缩比通常很高,但代价是**每次读写都要付出 CPU 成本**——适合"读取不频繁、体积大"的场景,不适合高 QPS 的热点数据。 ### Q:大 Key 怎么安全删除? A:三选一,按 Redis 版本和场景决定: ```java // 直接 DEL 大 Key 会阻塞 Redis(单线程)! // 方案一:UNLINK(Redis 4.0+,异步删除,推荐) redis.unlink(key); // UNLINK 在主线程中只做 Key 的解绑,实际内存释放在后台线程完成 // 方案二:分批删除(Redis 4.0 以下) public void deleteBigHash(String key) { ScanOptions options = ScanOptions.scanOptions().count(100).build(); try (Cursor<Map.Entry<Object, Object>> cursor = redis.opsForHash().scan(key, options)) { List<Object> fields = new ArrayList<>(); while (cursor.hasNext()) { fields.add(cursor.next().getKey()); if (fields.size() >= 100) { redis.opsForHash().delete(key, fields.toArray()); fields.clear(); Thread.sleep(10); // 每批删 100 个 field,休眠 10ms } } if (!fields.isEmpty()) { redis.opsForHash().delete(key, fields.toArray()); } } redis.delete(key); // 最后删除空 Key } // 方案三:开启 lazyfree(Redis 4.0+) // redis.conf // lazyfree-lazy-expire yes # 过期删除异步化 // lazyfree-lazy-server-del yes # 隐式删除异步化(如 RENAME 覆盖) // lazyfree-lazy-user-del yes # DEL 命令异步化(等同于 UNLINK) ``` > 关键区别:`UNLINK` 和 `lazyfree` 都是"把释放动作挪到后台线程",主线程立即返回;分批删除则是"把一次大操作拆成多次小操作",仍然占用主线程但每次耗时可控。**能用 `UNLINK` 就不要手写分批删除**——手写版本要考虑休眠间隔、异常中断后的续删等一堆边界问题。 ### Q:怎么防止大 Key 再次出现? A: | 措施 | 说明 | |------|------| | 设计阶段评估 | 预估 Key 的元素数量和大小,超过阈值就拆分 | | 定期巡检 | 定时任务扫描大 Key,发现后告警 | | 开启 lazyfree | Redis 4.0+ 开启异步删除,避免 DEL 阻塞 | | 监控慢查询 | `slowlog get` 监控耗时命令,大 Key 操作通常是慢查询 | | 避免全量操作 | 禁用 `HGETALL`、`SMEMBERS`、`LRANGE 0 -1`,用 `HSCAN`、`SSCAN` 分批读取 | 最后一条是最容易被忽略、却最有效的:**大 Key 之所以造成故障,往往是"大 Key + 全量命令"的组合**。把 `HGETALL` 换成 `HSCAN` 分批,即使 Key 暂时没拆,线上也不会被拖垮——这可以作为拆分之前的过渡方案。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A: 1. **发现大 Key**:`redis-cli --bigkeys` 快速扫描、`MEMORY USAGE` 精确查询、RDB 离线分析(生产推荐); 2. **拆分策略**:大 Hash 按 field 取模分桶、大 List 按分段存储、大 String 压缩存储; 3. **安全删除**:用 `UNLINK` 异步删除(Redis 4.0+),或 `HSCAN` + 分批删除;开启 `lazyfree` 配置; 4. **预防**:设计阶段评估数据量、禁用全量读取命令(`HGETALL`)、定期巡检 + 慢查询监控。 ### Q:为什么"给大 Key 扩容"不是解决办法? A:扩容只能缓解"内存倾斜",无法解决"单线程删除阻塞"和"全量命令搬运大量数据"这两个根本问题——只要 Key 还那么大,一次 `DEL` 或一次 `HGETALL` 仍然会阻塞主线程。**大 Key 的危害来自访问模式的串行性,而不是来自内存不够**,所以唯一的正解是拆分与避免全量操作。 --- ## 自测 1. `redis-cli --bigkeys` 的输出为什么可能漏掉真正的问题 Key? 2. 生产环境做全量大 Key 巡检,为什么推荐 RDB 离线分析而不是 `SCAN` + `MEMORY USAGE`? 3. 一个 Hash Key 暂时无法拆分,有什么"不改数据结构"的止血办法?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入