Spring Data Redis批量插入性能问题求助（Jedis转Lettuce）

我之前在项目中也遇到过从Jedis切换到Lettuce后，Spring Data Redis批量SADD操作性能下滑的情况，结合踩过的坑和优化经验，给你几个具体的解决方向：

1. 先检查Lettuce连接工厂的资源配置 #

Jedis默认是直连+多线程（每个请求一个连接）的模式，而Lettuce基于Netty实现，默认是共享长连接+异步事件循环的模式。如果你的连接工厂没配置合适的线程池，同步调用时很容易出现阻塞等待，拖慢性能。

建议调整Lettuce的客户端资源配置，给IO和计算线程池分配足够的资源：

@Bean
public LettuceConnectionFactory lettuceConnectionFactory() {
    RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration("your-redis-host", 6379);
    // 配置客户端资源，设置合理的线程池大小
    LettuceClientResources clientResources = LettuceClientResources.builder()
            .ioThreadPoolSize(Runtime.getRuntime().availableProcessors() * 2) // IO线程池，处理网络请求
            .computationThreadPoolSize(Runtime.getRuntime().availableProcessors()) // 计算线程池，处理命令回调
            .build();
    
    LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
            .clientResources(clientResources)
            .clientOptions(ClientOptions.builder()
                    .disconnectedBehavior(DisconnectedBehavior.REJECT_COMMANDS)
                    .build())
            .build();
    
    return new LettuceConnectionFactory(redisConfig, clientConfig);
}

2. 用批量SADD替代循环单条写入 #

这是最容易被忽略的点！如果你的代码是循环调用redisTemplate.opsForSet().add(key, singleItem)，不管用Jedis还是Lettuce都会慢——因为每个命令都要走一次网络往返。

换成批量版本的add方法，一次性传入多个元素：

// 把大列表拆分成合适的批次（比如每批1000个，根据Redis内存和网络情况调整）
List<List<YourPOJO>> batches = Lists.partition(largeDataList, 1000);
for (List<YourPOJO> batch : batches) {
    // 一次性传入整个批次的元素
    redisTemplate.opsForSet().add("your-set-key", batch.toArray());
}

批次大小可以根据实际情况调整，一般1000-5000个元素是比较合理的范围，太大可能会导致Redis命令执行时间过长，太小则无法发挥批量优势。

3. 利用Lettuce的异步API提高吞吐量 #

Lettuce天生支持异步操作，如果你用同步API，相当于把异步客户端当成同步用，没发挥它的优势。可以改用异步API结合CompletableFuture批量提交任务：

List<CompletableFuture<Long>> futures = new ArrayList<>();
List<List<YourPOJO>> batches = Lists.partition(largeDataList, 1000);

for (List<YourPOJO> batch : batches) {
    // 异步提交SADD任务
    CompletableFuture<Long> future = redisTemplate.opsForSet().addAsync("your-set-key", batch.toArray());
    futures.add(future);
}

// 等待所有任务完成
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();

这种方式可以让多个批量请求并行处理，充分利用Lettuce的异步能力，减少等待时间。

4. 开启流水线（Pipelining）减少网络往返 #

如果批量操作还不够，试试Redis的流水线功能——把多个命令打包成一个请求发送给Redis，减少网络往返次数。Spring Data Redis可以用executePipelined实现：

redisTemplate.executePipelined(new RedisCallback<Object>() {
    @Override
    public Object doInRedis(RedisConnection connection) throws DataAccessException {
        SetCommands setCommands = connection.setCommands();
        StringRedisSerializer serializer = (StringRedisSerializer) redisTemplate.getValueSerializer();
        
        for (YourPOJO item : largeDataList) {
            // 直接用底层命令提交，减少Spring封装的开销
            setCommands.sAdd(redisTemplate.getKeySerializer().serialize("your-set-key"),
                            serializer.serialize(item));
        }
        return null;
    }
});

注意：流水线适合纯写入的场景，不需要每个命令的返回值，如果需要统计写入数量，可以在流水线中收集结果。

5. 优化POJO的序列化性能 #

你提到用JSON序列化POJO，Jackson的序列化在批量场景下可能会有不小的开销。可以考虑换成更高效的序列化方式，比如Protobuf或者Kryo：

• Protobuf：需要定义proto文件，序列化后体积小、速度快，适合跨语言场景；
• Kryo：Java专属，序列化速度极快，配置简单。

以Kryo为例，配置RedisTemplate的序列化器：

@Bean
public RedisTemplate<String, YourPOJO> redisTemplate(LettuceConnectionFactory connectionFactory) {
    RedisTemplate<String, YourPOJO> template = new RedisTemplate<>();
    template.setConnectionFactory(connectionFactory);
    
    // 配置Kryo序列化器
    KryoSerializer kryoSerializer = new KryoSerializer();
    kryoSerializer.setClassLoader(Thread.currentThread().getContextClassLoader());
    
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(kryoSerializer);
    template.setHashKeySerializer(new StringRedisSerializer());
    template.setHashValueSerializer(kryoSerializer);
    
    return template;
}

序列化的优化在批量处理大量数据时，性能提升非常明显。

最后排查Redis服务器端的问题 #

如果客户端优化后还是慢，就要检查Redis服务器的状态：

• 用redis-cli info stats查看instantaneous_ops_per_sec（每秒操作数）、used_cpu_sys（系统CPU使用率）；
• 检查Redis是否开启了持久化（比如RDB快照或AOF日志），持久化过程可能会阻塞主线程；
• 查看Redis的内存使用情况，如果内存不足触发了swap，性能会急剧下降；
• 检查客户端和Redis之间的网络延迟，用redis-cli ping看响应时间，延迟过高会影响批量操作的速度。

内容的提问来源于stack exchange，提问作者Mauro Monti