你遇到的这个情况其实挺典型的——Redis和Lettuce对单次批量请求的大小/数量都有隐含限制，咱们一步步拆解解决方案：

为什么40万条会失败？ #

核心原因是单次请求的总数据量超过了Redis服务器或Lettuce客户端的阈值：

• Redis服务器默认有client-query-buffer-limit配置（普通客户端默认1GB），如果40万条键值对的总大小超过这个值，Redis会直接拒绝请求；另外proto-max-bulk-len（默认512MB）限制了单个value的最大长度，不过你的场景更可能是总请求量超标。
• Lettuce客户端虽然没有硬编码的请求大小限制，但超大请求容易引发网络超时、内存占用过高，甚至触发底层传输的隐性限制。

方案一：调整限制（临时/测试场景适用） #

如果只是想临时突破限制，可以从两端调整配置：

1. 修改Redis服务器配置 #

找到你的redis.conf文件，调整以下参数：

• client-query-buffer-limit normal 2gb：把普通客户端的请求缓冲区上限调高（根据你的数据量调整，比如2GB）
• proto-max-bulk-len 1gb：如果存在超大value，也可以同步调高这个值

修改后重启Redis生效。注意：这种方式会让Redis承担处理超大请求的压力，单线程的Redis在处理大请求时会阻塞其他业务，不推荐生产环境长期使用。

2. 调整Lettuce客户端配置 #

主要是延长超时时间，避免大请求因为传输慢被判定为超时：

ClientOptions clientOptions = ClientOptions.builder()
        .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(30))) // 延长超时到30秒
        .build();
RedisClient redisClient = RedisClient.create("redis://localhost:6379");
redisClient.setOptions(clientOptions);

方案二：分块批量插入（生产环境推荐） #

分块是更稳妥的方案，把40万条数据拆成多个小批次（比如每5万条一批，你已经验证过这个数量可行），分批执行MSET。这样既不会触发大小限制，也能避免Redis被大请求阻塞，重试成本也更低。

示例代码（同步分块） #

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisCommands;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.stream.Collectors;

public class RedisBulkInsert {
    public static void main(String[] args) {
        // 初始化Lettuce客户端
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");
        RedisCommands<String, String> syncCommands = redisClient.connect().sync();

        // 假设这里已经填充了40万条数据的大Map
        Map<String, String> largeDataMap = new HashMap<>();
        // ... 填充数据逻辑 ...

        int batchSize = 50000; // 每批次5万条，你已验证可行
        List<Map.Entry<String, String>> entryList = largeDataMap.entrySet().stream().toList();

        // 循环分块插入
        for (int i = 0; i < entryList.size(); i += batchSize) {
            int endIndex = Math.min(i + batchSize, entryList.size());
            Map<String, String> batchMap = entryList.subList(i, endIndex)
                    .stream()
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
            
            syncCommands.mset(batchMap);
            System.out.println("已插入第" + (i/batchSize +1) + "批次，共" + batchMap.size() + "条数据");
        }

        // 关闭资源
        syncCommands.close();
        redisClient.shutdown();
    }
}

进阶：异步分块提升性能 #

如果想更快完成插入，可以用Lettuce的异步API，让多个批次并行执行（注意不要开太多并发，避免压垮Redis）：

import io.lettuce.core.RedisAsyncCommands;
import io.lettuce.core.RedisFutures;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

// ... 初始化客户端逻辑 ...
RedisAsyncCommands<String, String> asyncCommands = redisClient.connect().async();
List<RedisFuture<Void>> futures = new ArrayList<>();

for (int i = 0; i < entryList.size(); i += batchSize) {
    int endIndex = Math.min(i + batchSize, entryList.size());
    Map<String, String> batchMap = entryList.subList(i, endIndex)
            .stream()
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    
    futures.add(asyncCommands.mset(batchMap));
}

// 等待所有异步任务完成
RedisFutures.awaitAll(futures);

总结 #

• 如果是临时测试场景，可以调整Redis和Lettuce的限制快速解决；
• 生产环境强烈推荐分块插入，兼顾稳定性和性能，还能避免Redis阻塞。

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