Redis大规模Key遍历实战：性能与安全的最佳实践

在Redis数据库的日常运维和开发过程中，我们经常需要遍历所有的key来执行各种操作，如统计、分析、迁移或清理数据。然而，在生产环境中，尤其是对于大型Redis实例，如何高效且安全地完成这一操作是一个重要的技术挑战。本文将详细介绍Redis中遍历所有key的各种方法、它们的优缺点以及最佳实践。

目录

1. 为什么需要遍历Redis的所有key
2. 遍历方法及其工作原理
   • KEYS命令
   • SCAN命令
   • 其他相关命令
3. 各种方法的优缺点比较
4. 生产环境中的最佳实践
5. 性能优化技巧
6. 实际案例和代码示例
7. 总结

为什么需要遍历Redis的所有key

在Redis的实际应用中，遍历所有key的需求非常常见，主要包括以下几种场景：

• 数据分析与统计：了解数据分布、key的数量、类型等信息
• 数据迁移：将数据从一个Redis实例迁移到另一个实例
• 缓存清理：批量删除符合特定模式的key
• 数据备份：导出所有数据进行备份
• 问题排查：查找异常数据或内存泄漏问题

然而，在大规模Redis实例中，key的数量可能达到数百万甚至数十亿级别，此时如何高效且不影响服务稳定性地遍历所有key就成为一个重要问题。

遍历方法及其工作原理

KEYS命令

KEYS是Redis提供的最直接的遍历命令，其语法为：

KEYS pattern

例如，KEYS *将返回所有的key。

工作原理：
KEYS命令会一次性返回所有匹配给定模式的key。Redis会扫描整个keyspace，这是一个O(N)的操作，N是数据库中key的总数。

SCAN命令

SCAN命令是Redis 2.8版本引入的，用于增量迭代key空间，其语法为：

SCAN cursor [MATCH pattern] [COUNT count] [TYPE type]

工作原理：
SCAN使用基于游标的迭代器，每次调用返回一个新的游标，用于下一次迭代。它是一个增量操作，每次只返回一部分结果，不会阻塞Redis服务器。

• cursor：游标值，第一次调用时为0
• MATCH pattern：可选参数，指定匹配的模式
• COUNT count：可选参数，指定每次迭代返回的key数量（默认为10）
• TYPE type：可选参数，指定返回的key类型（Redis 6.0新增）

示例：

SCAN 0 MATCH user:* COUNT 100

其他相关命令

除了KEYS和SCAN外，Redis还提供了一些特定数据类型的遍历命令：

• HSCAN：用于遍历Hash类型的字段
• SSCAN：用于遍历Set类型的元素
• ZSCAN：用于遍历Sorted Set类型的元素

这些命令的工作原理与SCAN类似，都是基于游标的增量迭代。

各种方法的优缺点比较

KEYS命令

优点：

• 使用简单直观
• 一次性返回所有匹配的key

缺点：

• 阻塞操作，会锁住Redis服务器直到命令执行完成
• 在大型数据库中可能导致服务不可用
• 时间复杂度为O(N)，随着key数量增加，执行时间线性增长

SCAN命令

优点：

• 非阻塞操作，每次只返回一部分结果
• 不会导致Redis服务器长时间不可用
• 可以通过COUNT参数控制每次返回的结果数量
• 支持模式匹配和类型过滤

缺点：

• 使用相对复杂，需要客户端维护游标状态
• 可能会返回重复的key，需要客户端去重
• 遍历过程中如果有key被删除或新增，可能会漏掉或重复处理某些key
• 完整遍历的总时间可能比KEYS命令更长

生产环境中的最佳实践

在生产环境中安全高效地遍历Redis的所有key，应遵循以下最佳实践：

1. 避免使用KEYS命令

在生产环境中，尤其是对于大型Redis实例，应该完全避免使用KEYS命令。即使在低峰期，KEYS命令也可能导致服务不可用。

2. 使用SCAN命令进行增量迭代

使用SCAN命令是生产环境中遍历key的推荐方法。以下是使用SCAN的一些建议：

• 合理设置COUNT参数：根据实例大小和性能调整COUNT值，通常在100-1000之间
• 在低峰期执行：尽量在系统负载较低的时间段执行大规模遍历
• 控制迭代速度：在每次SCAN调用之间添加适当的延迟，减少对Redis的压力
• 使用TYPE过滤：如果只需要特定类型的key，使用TYPE参数进行过滤

3. 使用Redis Cluster时的注意事项

在Redis Cluster环境中，需要对每个节点分别执行SCAN命令，因为每个节点只包含部分key空间。

4. 使用Lua脚本优化操作

对于需要在遍历过程中执行复杂操作的场景，可以使用Lua脚本将多个操作合并，减少网络往返和命令执行开销。

5. 监控系统资源

在执行大规模遍历操作时，应密切监控Redis的CPU使用率、内存使用情况和响应时间，一旦发现异常，立即暂停操作。

性能优化技巧

1. 使用合适的数据结构

合理设计key的命名和组织方式，可以减少遍历的需求。例如，使用Hash类型存储相关数据，而不是使用多个独立的key。

2. 分批处理

将大量key的处理分成多个小批次，每个批次处理完成后再进行下一批次，避免长时间占用Redis资源。

3. 利用Redis的内存优化功能

使用Redis的内存优化功能，如maxmemory和maxmemory-policy，控制Redis的内存使用，避免因key过多导致内存溢出。

4. 使用二级索引

对于需要频繁按特定条件查询的场景，可以维护二级索引（如Sorted Set），避免全量遍历。

5. 使用Redis模块扩展

某些Redis模块（如RedisSearch）提供了更高效的索引和查询功能，可以替代全量遍历。

实际案例和代码示例 JDK17 如果想使用JDK8,RedisLuaExample 需要调整一下

使用SCAN命令遍历所有key（使用Jedis）

import redis.clients.jedis.Jedis;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;import java.util.HashSet;
import java.util.Set;public class RedisScanExample {/*** 使用SCAN命令安全地遍历所有key** @param jedis Redis客户端连接* @param matchPattern 匹配模式，默认为"*"匹配所有key* @param count 每次迭代返回的key数量* @param delayMillis 每次迭代之间的延迟时间（毫秒）* @return 所有匹配的key的集合*/public static Set<String> scanAllKeys(Jedis jedis, String matchPattern, int count, long delayMillis) {String cursor = "0";Set<String> allKeys = new HashSet<>();ScanParams scanParams = new ScanParams().match(matchPattern).count(count);try {do {ScanResult<String> scanResult = jedis.scan(cursor, scanParams);cursor = scanResult.getCursor();allKeys.addAll(scanResult.getResult());// 添加延迟，减少对Redis的压力if (delayMillis > 0) {Thread.sleep(delayMillis);}} while (!"0".equals(cursor));return allKeys;} catch (InterruptedException e) {Thread.currentThread().interrupt();throw new RuntimeException("Scanning interrupted", e);}}public static void main(String[] args) {try (Jedis jedis = new Jedis("localhost", 6379)) {Set<String> keys = scanAllKeys(jedis, "user:*", 500, 50);System.out.printf("找到 %d 个匹配的key%n", keys.size());}}
}

使用Lua脚本批量处理key（使用Jedis）

import redis.clients.jedis.Jedis;
import redis.clients.jedis.exceptions.JedisException;import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;public class RedisLuaExample {private static final String LUA_SCRIPT = """local cursor = ARGV[1]local pattern = ARGV[2]local count = ARGV[3]local result = {}local scan_result = redis.call('SCAN', cursor, 'MATCH', pattern, 'COUNT', count)local new_cursor = scan_result[1]local keys = scan_result[2]for i, key in ipairs(keys) dolocal ttl = redis.call('TTL', key)table.insert(result, key)table.insert(result, ttl)endtable.insert(result, 1, new_cursor)return result""";/*** 使用Lua脚本批量处理匹配的key** @param jedis Redis客户端连接* @param matchPattern 匹配模式* @param batchSize 每批处理的key数量* @return 包含key和其TTL的Map*/public static Map<String, Long> processKeysWithLua(Jedis jedis, String matchPattern, int batchSize) {String cursor = "0";Map<String, Long> results = new HashMap<>();String sha = jedis.scriptLoad(LUA_SCRIPT);try {do {List<String> args = new ArrayList<>();args.add(cursor);args.add(matchPattern);args.add(String.valueOf(batchSize));@SuppressWarnings("unchecked")List<String> response = (List<String>) jedis.evalsha(sha, 0, args.toArray(new String[0]));cursor = response.get(0);// 处理结果for (int i = 1; i < response.size(); i += 2) {String key = response.get(i);Long ttl = Long.parseLong(response.get(i + 1));results.put(key, ttl);}} while (!"0".equals(cursor));return results;} catch (JedisException e) {throw new RuntimeException("Error executing Lua script", e);}}public static void main(String[] args) {try (Jedis jedis = new Jedis("localhost", 6379)) {Map<String, Long> keyTtls = processKeysWithLua(jedis, "session:*", 200);System.out.printf("处理了 %d 个key%n", keyTtls.size());}}
}

在Redis 中遍历所有key（使用Redisson）

import org.redisson.Redisson;
import org.redisson.api.RKeys;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;/*** @author heyi* 2025/6/25*/
public class RedisRedissonScanExample {/*** 在Redis Cluster中遍历所有key** @param redisson     Redisson客户端* @param matchPattern 匹配模式* @param count        每次迭代返回的key数量* @return 所有匹配的key的集合*/public static Set<String> scanAllKeysInCluster(RedissonClient redisson, String matchPattern, int count) {Set<String> allKeys = new HashSet<>();RKeys keys = redisson.getKeys();// 使用Redisson的迭代器遍历所有keyIterator<String> keyIterator = keys.getKeysByPattern(matchPattern, count).iterator();while (keyIterator.hasNext()) {allKeys.add(keyIterator.next());}return allKeys;}public static void main(String[] args) {// 配置Redis集群Config config = new Config();config.useSingleServer().setAddress("redis://127.0.0.1:6379").setConnectTimeout(5000).setRetryAttempts(3);RedissonClient redisson = Redisson.create(config);Set<String> keys = scanAllKeysInCluster(redisson, "user:*", 500);System.out.printf("在redis中找到 %d 个匹配的key%n", keys.size());}
}

POM文件

 <dependencies><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>4.2.3</version></dependency><dependency><groupId>org.redisson</groupId><artifactId>redisson</artifactId><version>3.45.1</version></dependency></dependencies><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><configuration><source>17</source><target>17</target></configuration></plugin></plugins></build>

总结

高效安全地遍历Redis中的所有key是一项需要谨慎处理的操作，尤其是在生产环境中。本文介绍了几种遍历方法及其优缺点，并提供了最佳实践和优化技巧。

关键要点总结：

1. 避免使用KEYS命令：在生产环境中，KEYS命令可能导致服务不可用
2. 使用SCAN命令：SCAN是增量迭代的，不会阻塞Redis服务器
3. 控制遍历速度：合理设置COUNT参数并添加适当的延迟

欢迎大家点赞，收藏，评论，转发，你们的支持是我最大的写作动力