JAVA 系统中 Redis 大 Key 造成阻塞？实测分析与拆分优化策略
各位同学，今天我们来聊聊一个在 Java 系统中使用 Redis 时经常会遇到的问题：大 Key 造成的阻塞。这个问题看似简单，但处理不好可能会严重影响系统的性能和稳定性。今天我将从理论到实践，通过实测分析和具体的拆分优化策略，帮助大家彻底理解并解决这个问题。
一、什么是 Redis 大 Key？
首先，我们需要明确什么是 Redis 大 Key。简单来说，就是指 Key 对应 Value 的大小超过了某个阈值。这个阈值并没有一个绝对的标准，通常取决于你的硬件配置、网络带宽以及对延迟的容忍度。
一般来说，以下情况可以被认为是 Redis 大 Key：
- String 类型：Value 超过 10KB
- List、Set、Hash、ZSet 类型：元素数量超过 1000 个，或者 Value 的总大小超过 1MB
需要注意的是，这只是一个参考值，实际应用中需要根据具体情况进行调整。比如，你的 Redis 服务器部署在高带宽低延迟的网络环境中，可能可以容忍更大的 Key。
二、大 Key 造成的阻塞原理
Redis 是单线程的，所有操作都在一个线程中执行。这意味着如果某个操作耗时过长，就会阻塞后续的操作。而大 Key 的操作往往会消耗大量的 CPU 和内存资源，从而导致阻塞。
具体来说，大 Key 造成的阻塞主要体现在以下几个方面：
- 读操作阻塞：读取大 Key 需要从磁盘或内存中加载大量数据，这会占用大量的 CPU 和 I/O 资源，阻塞其他读写操作。
- 写操作阻塞：写入大 Key 需要分配大量的内存空间，并且可能需要进行序列化和反序列化操作，这也会导致阻塞。
- 删除操作阻塞：删除大 Key 需要释放大量的内存空间，同样会导致阻塞。更严重的是，如果使用
DEL命令删除一个非常大的 Key，可能会阻塞 Redis 服务器很长时间，甚至导致服务不可用。 - 过期删除阻塞：Redis 的过期删除策略有两种：惰性删除和定期删除。如果惰性删除遇到大 Key，或者定期删除采样到大 Key，都会造成阻塞。
- 主从复制阻塞：主节点在同步数据到从节点时，如果遇到大 Key，会导致复制延迟，甚至导致主从节点数据不一致。
三、实测分析：模拟大 Key 场景
为了更直观地了解大 Key 造成的阻塞，我们来做一个简单的实验。
-
实验环境：
- Redis 服务器：单机部署，版本 6.2.x
- Java 客户端：Jedis
- 测试工具：JMeter
-
实验步骤：
- Step 1： 准备数据。创建一个 Java 程序，生成一个 Value 很大的 String 类型的 Key，例如 1MB 大小。
import redis.clients.jedis.Jedis;
import java.util.Random;
public class BigKeyGenerator {
public static void main(String[] args) { Jedis jedis = new Jedis("localhost", 6379); jedis.auth("your_redis_password"); // 如果 Redis 启用了密码认证 String key = "big_key"; int valueSize = 1024 * 1024; // 1MB String value = generateRandomString(valueSize); long startTime = System.currentTimeMillis(); jedis.set(key, value); long endTime = System.currentTimeMillis(); System.out.println("Set big key time: " + (endTime - startTime) + " ms"); jedis.close(); } private static String generateRandomString(int size) { StringBuilder sb = new StringBuilder(size); Random random = new Random(); for (int i = 0; i < size; i++) { sb.append((char) (random.nextInt(26) + 'a')); } return sb.toString(); }}
* **Step 2：**使用 JMeter 模拟并发请求。设置多个线程并发地读取和写入 Redis，包括对大 Key 的读写操作。 * **Step 3：** 观察 Redis 服务器的 CPU 使用率、内存使用率、延迟等指标。可以使用 `redis-cli` 的 `INFO` 命令或者 RedisInsight 等工具进行监控。 * **Step 4：** 分析实验结果。观察并发请求的响应时间，以及 Redis 服务器的各项指标，可以明显看到大 Key 的存在导致了延迟增加和阻塞。 - Step 1： 准备数据。创建一个 Java 程序，生成一个 Value 很大的 String 类型的 Key，例如 1MB 大小。
-
实验结果分析：
通过实验，我们可以观察到以下现象：
- 响应时间增加：并发请求的响应时间明显增加，特别是涉及到大 Key 的操作。
- CPU 使用率升高：Redis 服务器的 CPU 使用率升高，因为处理大 Key 需要消耗大量的 CPU 资源。
- 延迟波动：Redis 服务器的延迟出现明显的波动，这是由于大 Key 的操作阻塞了其他操作。
四、大 Key 的识别方法
在实际应用中，我们需要先识别出哪些 Key 是大 Key，才能进行针对性的优化。以下是一些常用的识别方法：
-
redis-cli –bigkeys：Redis 自带的
redis-cli工具提供了一个--bigkeys选项，可以扫描 Redis 数据库，找出最大的 Key。redis-cli --bigkeys -h your_redis_host -p your_redis_port -a your_redis_password这个命令会扫描 Redis 数据库，并输出最大的 Key 的类型、大小等信息。但是，这个命令会阻塞 Redis 服务器，不建议在生产环境中使用。
-
SCAN 命令：可以使用 Redis 的
SCAN命令逐步遍历数据库，并检查每个 Key 的大小。import redis.clients.jedis.Jedis; import redis.clients.jedis.ScanParams; import redis.clients.jedis.ScanResult; import java.util.List; import java.util.Set; public class BigKeyScanner { public static void main(String[] args) { Jedis jedis = new Jedis("localhost", 6379); jedis.auth("your_redis_password"); // 如果 Redis 启用了密码认证 String cursor = "0"; ScanParams scanParams = new ScanParams().count(100); // 每次扫描 100 个 Key int bigKeyThreshold = 1024 * 10; // 10KB do { ScanResult<String> scanResult = jedis.scan(cursor, scanParams); List<String> keys = scanResult.getResult(); cursor = scanResult.getCursor(); for (String key : keys) { String type = jedis.type(key); long size = 0; switch (type) { case "string": size = jedis.strlen(key); break; case "list": size = jedis.llen(key); break; case "set": size = jedis.scard(key); break; case "hash": size = jedis.hlen(key); break; case "zset": size = jedis.zcard(key); break; default: System.out.println("Unsupported type: " + type); continue; } if (size > bigKeyThreshold) { System.out.println("Big key found: " + key + ", type: " + type + ", size: " + size); } } } while (!cursor.equals("0")); jedis.close(); } }这个方法不会阻塞 Redis 服务器，但是需要遍历整个数据库，效率相对较低。
-
RedisInsight：RedisInsight 是 Redis 官方提供的可视化工具，可以方便地监控 Redis 服务器的各项指标，包括 Key 的大小。通过 RedisInsight，可以快速找到大 Key。
-
监控系统：可以集成 Redis 的监控指标到现有的监控系统中，例如 Prometheus、Grafana 等。通过监控系统，可以实时了解 Redis 服务器的运行状态，及时发现大 Key。
五、大 Key 的拆分优化策略
找到大 Key 之后，我们需要对其进行拆分优化，以避免阻塞 Redis 服务器。以下是一些常用的拆分优化策略：
-
String 类型：
- 拆分成多个小 Key：可以将一个大的 String 类型的值拆分成多个小 Key，例如按照时间戳或者 ID 进行拆分。
- 压缩：可以使用 Gzip 等压缩算法对 Value 进行压缩，减小 Value 的大小。
- 使用 Stream： 如果 value 是日志或者事件类型的数据，可以考虑使用 Redis Stream 数据结构，Stream 可以将数据分割成多个消息，并提供消费组等功能，避免单个 key 过大。
示例：
假设有一个存储用户信息的 Key，Value 是一个很大的 JSON 字符串。可以将用户信息拆分成多个小 Key，例如：
user:123:name：存储用户的姓名user:123:age：存储用户的年龄user:123:address：存储用户的地址
这样，每次只需要读取需要的信息，而不需要读取整个 JSON 字符串。
import redis.clients.jedis.Jedis; import java.util.HashMap; import java.util.Map; public class StringKeySplitter { public static void main(String[] args) { Jedis jedis = new Jedis("localhost", 6379); jedis.auth("your_redis_password"); // 如果 Redis 启用了密码认证 String bigKey = "user:123"; String bigValue = "{"name":"John Doe","age":30,"address":"123 Main St"}"; // 模拟从数据库中获取大数据 Map<String, String> userInfo = parseJson(bigValue); // 拆分成多个小 Key for (Map.Entry<String, String> entry : userInfo.entrySet()) { String field = entry.getKey(); String value = entry.getValue(); jedis.set(bigKey + ":" + field, value); } // 读取小 Key String name = jedis.get(bigKey + ":name"); String age = jedis.get(bigKey + ":age"); String address = jedis.get(bigKey + ":address"); System.out.println("Name: " + name); System.out.println("Age: " + age); System.out.println("Address: " + address); jedis.close(); } private static Map<String, String> parseJson(String json) { // 这里只是一个简单的示例，实际应用中需要使用专业的 JSON 解析库 Map<String, String> map = new HashMap<>(); if (json.contains(""name"")) { map.put("name", json.substring(json.indexOf(":"") + 2, json.indexOf("","age""))); } if (json.contains(""age"")) { map.put("age", json.substring(json.indexOf("age":") + 5, json.indexOf(","address""))); } if (json.contains(""address"")) { map.put("address", json.substring(json.indexOf("address":"") + 10, json.indexOf(""}"))); } return map; } } -
List、Set、Hash、ZSet 类型：
- 拆分成多个小 Key：可以将一个大的 List、Set、Hash、ZSet 拆分成多个小 Key，例如按照范围或者 Hash 值进行拆分。
- 分页：可以使用分页的方式读取数据，每次只读取一部分数据。
- 渐进式操作：可以使用
HSCAN、SSCAN、ZSCAN等命令进行渐进式操作，避免一次性读取大量数据。
示例：
假设有一个存储用户关注列表的 Set，Key 是
user:123:following，Value 包含大量的用户 ID。可以将用户关注列表拆分成多个小 Key，例如：user:123:following:0：存储用户关注列表的前 1000 个用户 IDuser:123:following:1：存储用户关注列表的第 1001-2000 个用户 IDuser:123:following:2：存储用户关注列表的第 2001-3000 个用户 ID
这样，每次只需要读取需要的部分数据，而不需要读取整个 Set。
import redis.clients.jedis.Jedis; import redis.clients.jedis.ScanParams; import redis.clients.jedis.ScanResult; import java.util.HashSet; import java.util.List; import java.util.Set; public class SetKeySplitter { public static void main(String[] args) { Jedis jedis = new Jedis("localhost", 6379); jedis.auth("your_redis_password"); // 如果 Redis 启用了密码认证 String bigKey = "user:123:following"; int totalUsers = 5000; // 模拟有 5000 个关注用户 int splitSize = 1000; // 每个小 key 存储 1000 个用户 // 模拟生成大数据 Set<String> allUsers = new HashSet<>(); for (int i = 0; i < totalUsers; i++) { allUsers.add("user:" + i); } // 拆分成多个小 Key int index = 0; int count = 0; Set<String> currentSet = new HashSet<>(); for (String user : allUsers) { currentSet.add(user); count++; if (count == splitSize) { String smallKey = bigKey + ":" + index; jedis.sadd(smallKey, currentSet.toArray(new String[0])); currentSet.clear(); index++; count = 0; } } // 处理剩余的用户 if (!currentSet.isEmpty()) { String smallKey = bigKey + ":" + index; jedis.sadd(smallKey, currentSet.toArray(new String[0])); } // 读取小 Key (使用 SCAN 迭代读取) Set<String> retrievedUsers = new HashSet<>(); String cursor = "0"; ScanParams scanParams = new ScanParams().count(100); int keyIndex = 0; do { String smallKey = bigKey + ":" + keyIndex; ScanResult<String> scanResult = jedis.sscan(smallKey, cursor, scanParams); List<String> users = scanResult.getResult(); retrievedUsers.addAll(users); cursor = scanResult.getCursor(); if (cursor.equals("0")) { keyIndex++; cursor = "0"; // Reset cursor for the next key } } while (keyIndex <= index); // 确保遍历所有小 key System.out.println("Retrieved " + retrievedUsers.size() + " users"); jedis.close(); } } -
删除大 Key：
- 避免使用
DEL命令：尽量避免使用DEL命令删除大 Key，因为它会阻塞 Redis 服务器。 - 使用
UNLINK命令：可以使用UNLINK命令异步删除大 Key。UNLINK命令会将 Key 从数据库中移除，但不会立即释放内存空间，而是交给后台线程异步处理。 - 分批删除：对于 List、Set、Hash、ZSet 类型的大 Key，可以使用
LPOP、SPOP、HSCAN、ZREMRANGEBYRANK等命令分批删除数据。
示例：
import redis.clients.jedis.Jedis; public class BigKeyDeleter { public static void main(String[] args) { Jedis jedis = new Jedis("localhost", 6379); jedis.auth("your_redis_password"); // 如果 Redis 启用了密码认证 String bigKey = "big_list"; // 模拟创建一个很大的 List for (int i = 0; i < 5000; i++) { jedis.lpush(bigKey, "item:" + i); } // 分批删除 List 中的元素 long listLength = jedis.llen(bigKey); int batchSize = 100; for (int i = 0; i < listLength; i += batchSize) { for (int j = 0; j < batchSize; j++) { jedis.lpop(bigKey); } } System.out.println("Big key deleted successfully."); jedis.close(); } } - 避免使用
-
过期删除：
- 设置合理的过期时间：为 Key 设置合理的过期时间，避免 Key 长期占用内存。
- 避免大量 Key 同时过期：避免大量 Key 同时过期，导致 Redis 服务器在短时间内执行大量的过期删除操作。可以采用随机过期时间的方式，将过期时间分散开来。
示例：
import redis.clients.jedis.Jedis; import java.util.Random; public class ExpirationTimeSetter { public static void main(String[] args) { Jedis jedis = new Jedis("localhost", 6379); jedis.auth("your_redis_password"); // 如果 Redis 启用了密码认证 String key = "my_key"; String value = "my_value"; jedis.set(key, value); // 设置随机过期时间，避免大量 Key 同时过期 Random random = new Random(); int expirationTime = 60 + random.nextInt(30); // 60-90 秒之间 jedis.expire(key, expirationTime); System.out.println("Key expiration time set to " + expirationTime + " seconds."); jedis.close(); } }
六、其他优化建议
除了上述拆分优化策略之外，还有一些其他的优化建议：
- 选择合适的数据结构：根据实际需求选择合适的数据结构，避免使用不必要的数据结构。例如，如果只需要存储简单的键值对，可以使用 String 类型，而不需要使用 Hash 类型。
- 优化 Key 的设计：Key 的设计应该简洁明了，避免使用过长的 Key。过长的 Key 会增加内存占用，并且会降低查询效率。
- 使用 Pipeline：可以使用 Pipeline 批量执行多个 Redis 命令，减少网络开销。
- 使用 Lua 脚本：可以使用 Lua 脚本将多个 Redis 命令原子性地执行，避免并发问题。
- 升级 Redis 版本：新版本的 Redis 通常会包含性能优化和 bug 修复，升级到新版本可以提高 Redis 服务器的性能。
- 使用 Redis 集群：如果单机 Redis 服务器无法满足需求，可以考虑使用 Redis 集群，将数据分散到多个节点上，提高系统的吞吐量和可用性。
- 监控和报警：建立完善的监控和报警系统，及时发现和解决问题。
总结与建议
今天我们深入探讨了 Java 系统中使用 Redis 时遇到的一个常见问题：大 Key 造成的阻塞。通过实测分析，我们直观地了解了大 Key 对系统性能的影响。 针对不同类型的大 Key，我们详细介绍了拆分、压缩、分页、渐进式操作等多种优化策略，并提供了相应的 Java 代码示例。此外，还分享了选择合适的数据结构、优化 Key 的设计、使用 Pipeline 和 Lua 脚本等其他优化建议。
希望今天的分享能帮助大家更好地理解和解决 Redis 大 Key 问题，提升系统的性能和稳定性。 在实际应用中，需要根据具体情况选择合适的优化策略，并不断进行监控和调整。