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) do
                local ttl = redis.call('TTL', key)
                table.insert(result, key)
                table.insert(result, ttl)
            end
            
            table.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的迭代器遍历所有key
      Iterator<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.clientsgroupId>
            <artifactId>jedisartifactId>
            <version>4.2.3version>
        dependency>

        <dependency>
            <groupId>org.redissongroupId>
            <artifactId>redissonartifactId>
            <version>3.45.1version>
        dependency>
    dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <configuration>
                    <source>17source>
                    <target>17target>
                configuration>
            plugin>
        plugins>
    build>

总结

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

关键要点总结：

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

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