每天和 Redis 打交道的你，是不是经常会遇到需要执行成百上千个命令的场景？每个命令都要等待上一个执行完毕，这种来回的网络延迟让你的程序龟速前进。Pipeline 就是为解决这个问题而生的，它能让你的 Redis 操作速度提升数倍甚至数十倍。
Redis Pipeline 是什么
Pipeline（管道）是 Redis 提供的一种批量执行命令的机制，它允许客户端一次性发送多个命令到服务器，而不需要等待每个命令的响应，最后再一次性接收所有命令的响应结果。
注意：Pipeline 功能自 Redis 2.0 起支持，确保服务端版本不低于此。
为什么需要 Pipeline
在 Redis 的通常使用模式中，客户端发送一个命令到服务器，然后等待服务器的响应，这个过程中存在网络往返时间（RTT, Round-Trip Time）。如果你需要执行大量命令，这些 RTT 会累加起来，成为性能瓶颈。
举个简单的例子：假设网络延迟是 1 毫秒（非常理想的情况），执行 1000 个命令：
- 普通模式：至少需要 1000ms（1 秒）
- Pipeline 模式：理论上只需要 2ms（发送和接收各一次）
Pipeline 的实现原理
Pipeline 巧妙地利用了 TCP 协议的特性和 Redis 的命令处理机制：
graph TD
A[客户端] -->|1.收集并缓存命令| B[命令队列]
B -->|2.批量发送| C[TCP缓冲区]
C -->|3.网络传输| D[Redis服务器]
D -->|4.命令处理| E[命令处理队列]
E -->|5.批量执行| F[命令执行器]
F -->|6.生成响应| G[响应队列]
G -->|7.批量发送| H[客户端]
协议层原理
Pipeline 利用 TCP 的流式传输特性和 Nagle 算法（小数据包合并），将多个命令按 RESP 协议格式拼接成单个数据包发送：
*3\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n
*3\r\n$3\r\nGET\r\n$3\r\nkey\r\n
这避免了单个命令的 TCP 小包开销。单条命令内存占用约为：
单条命令内存 = RESP协议开销 + 命令字符串长度 + 结果缓存大小
（例如：SET key value 的RESP格式约占27字节）
TCP 缓冲区大小会限制单次 Pipeline 能发送的命令量，可以用这个公式估算：
单次最大命令量 ≈ TCP缓冲区大小（80KB） / 单条命令平均字节数（如50字节）≈ 1600条
（实际需预留缓冲区空间，建议设置为1000条以内）
Redis 服务端接收到 Pipeline 中的命令后，会依次执行这些命令，并将所有结果缓存起来，然后一次性返回给客户端。这个过程中：
- 减少了网络交互次数
- 减少了网络 IO 的系统调用次数
- 避免了每次命令之间的等待时间
Java 中如何使用 Pipeline
在 Java 中，可以通过 Jedis、Lettuce 或 Redisson 等客户端库使用 Pipeline 功能。下面分别展示两种常用客户端的实现：
使用 Jedis 的 Pipeline
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Response;
import redis.clients.jedis.exceptions.JedisDataException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class JedisPipelineExample {
public static void main(String[] args) {
try (Jedis jedis = new Jedis("localhost", 6379)) {
// 1. 基本使用方式
Pipeline pipeline = jedis.pipelined();
for (int i = 0; i < 100; i++) {
pipeline.set("key" + i, "value" + i);
}
// 执行并获取所有结果
try {
pipeline.sync(); // 发送所有命令到Redis服务器
} catch (JedisDataException e) {
System.err.println("Pipeline执行异常: " + e.getMessage());
// 生产环境建议：使用SLF4J等日志框架替代System.err
}
// 2. 如果需要获取返回结果
pipeline = jedis.pipelined();
Map<String, Response<String>> responseMap = new HashMap<>();
// 注意：此时命令并未发送到Redis，只是在客户端排队
for (int i = 0; i < 100; i++) {
// Response是异步结果的容器，此时还没有实际值
responseMap.put("key" + i, pipeline.get("key" + i));
}
// 执行命令（此时命令才真正发送到Redis，结果存入Response对象）
pipeline.sync();
// 获取结果（必须在sync之后调用get()，否则会阻塞等待结果）
for (Map.Entry<String, Response<String>> entry : responseMap.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue().get());
}
// 3. 清理测试数据
pipeline = jedis.pipelined();
for (int i = 0; i < 100; i++) {
pipeline.del("key" + i);
}
pipeline.sync();
} catch (Exception e) {
System.err.println("异常: " + e.getMessage());
}
}
}
使用 Spring Data Redis 的 Pipeline
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Objects;
@Service
public class RedisPipelineService {
@Autowired
private RedisTemplate<String, String> redisTemplate;
public void pipelineOperations() {
try {
List<Object> results = redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
// 开启pipeline
connection.openPipeline();
// 执行多个命令
for (int i = 0; i < 100; i++) {
connection.stringCommands().set(
("key" + i).getBytes(),
("value" + i).getBytes()
);
}
// 这里返回null，结果会被pipeline收集
return null;
});
// 输出结果数量和类型
System.out.println("Pipeline executed with " + results.size() + " results");
// SET命令在Pipeline中无实际返回值（仅确认命令入队），结果通常为null或Redis的状态码包装类型
for (int i = 0; i < results.size(); i++) {
System.out.println("SET result " + i + ": " + results.get(i) +
" (type: " + (results.get(i) != null ? results.get(i).getClass().getSimpleName() : "null") + ")");
}
} catch (Exception e) {
System.err.println("异常: " + e.getMessage());
}
}
public void pipelineWithResults() {
try {
List<Object> results = redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
// 执行多个命令并收集结果
for (int i = 0; i < 10; i++) {
String key = "key" + i;
connection.stringCommands().set(key.getBytes(), ("value" + i).getBytes());
connection.stringCommands().get(key.getBytes());
}
// 这里返回null，实际结果会被pipeline收集
return null;
});
// 结果处理（包括错误处理）
for (int i = 0; i < results.size(); i++) {
Object result = results.get(i);
if (result instanceof Exception) {
System.err.println("命令 " + i + " 失败: " + ((Exception) result).getMessage());
} else {
// 由于RedisTemplate默认使用StringRedisSerializer，此处可直接转换为String
// 若使用自定义序列化，需根据实际情况处理字节数组
System.out.println("命令 " + i + " 成功: " + (result instanceof byte[] ? new String((byte[]) result) : result));
}
}
} catch (Exception e) {
System.err.println("异常: " + e.getMessage());
}
}
public void cleanupTestData() {
redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
for (int i = 0; i < 100; i++) {
connection.keyCommands().del(("key" + i).getBytes());
}
return null;
});
}
}
Pipeline 性能测试
让我们通过一个简单的性能测试来直观感受 Pipeline 的威力：
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.exceptions.JedisException;
public class PipelinePerformanceTest {
private static final int LOOP_COUNT = 10000;
public static void main(String[] args) {
try (Jedis jedis = new Jedis("localhost", 6379)) {
// 测试普通模式
long startTime = System.currentTimeMillis();
try {
for (int i = 0; i < LOOP_COUNT; i++) {
jedis.set("normal_" + i, "value");
jedis.get("normal_" + i);
}
} catch (JedisException e) {
System.err.println("异常: " + e.getMessage());
}
long normalUsedTime = System.currentTimeMillis() - startTime;
// 测试Pipeline模式
startTime = System.currentTimeMillis();
try {
Pipeline pipeline = jedis.pipelined();
for (int i = 0; i < LOOP_COUNT; i++) {
pipeline.set("pipeline_" + i, "value");
pipeline.get("pipeline_" + i);
}
pipeline.sync();
} catch (JedisException e) {
System.err.println("异常: " + e.getMessage());
}
long pipelineUsedTime = System.currentTimeMillis() - startTime;
System.out.println("Normal mode used: " + normalUsedTime + "ms");
System.out.println("Pipeline mode used: " + pipelineUsedTime + "ms");
System.out.println("Pipeline is " + (normalUsedTime / pipelineUsedTime) + "x faster");
System.out.println("RTT次数对比: 普通模式=" + (LOOP_COUNT*2) + "次, Pipeline模式=2次");
// 清理测试数据
try {
Pipeline pipeline = jedis.pipelined();
for (int i = 0; i < LOOP_COUNT; i++) {
pipeline.del("normal_" + i);
pipeline.del("pipeline_" + i);
}
pipeline.sync();
} catch (JedisException e) {
System.err.println("异常: " + e.getMessage());
}
}
}
}
测试环境：
- Redis 7.0.11（单节点，本地环回接口）
- Jedis 4.4.3
- 客户端/服务器：同一台机器（Intel i7 CPU, 16GB RAM）
测试结果（仅供参考）：
- 普通模式: 约 12000ms
- Pipeline 模式: 约 800ms
- 性能提升: 约 15 倍
实际结果会因网络环境、Redis 服务器负载等因素而异。通常 Pipeline 对于网络延迟越高的环境，提升效果越明显。
graph TD
title["执行时间对比(ms)"]
normal[普通模式: 12000ms]
pipeline[Pipeline模式: 800ms]
style title fill:#f9f9f9,stroke:#333,stroke-width:1px
style normal fill:#ff9999,stroke:#333,stroke-width:1px
style pipeline fill:#99ff99,stroke:#333,stroke-width:1px
title --> normal
title --> pipeline
实战案例：批量导入数据
假设我们需要将一个大型 CSV 文件中的数据导入到 Redis 中，使用 Pipeline 可以大大提高导入效率：
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.jedis.exceptions.JedisException;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class DataImporter {
private static final int BATCH_SIZE = 1000; // 每个批次的数据量
public static void main(String[] args) {
String filePath = "large_data.csv";
try (Jedis jedis = new Jedis("localhost", 6379)) {
importData(jedis, filePath);
} catch (IOException e) {
System.err.println("异常: " + e.getMessage());
} catch (Exception e) {
System.err.println("异常: " + e.getMessage());
}
}
public static void importData(Jedis jedis, String filePath) throws IOException {
long startTime = System.currentTimeMillis();
int totalCount = 0;
int batchCount = 0;
try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
String line;
Pipeline pipeline = jedis.pipelined();
while ((line = reader.readLine()) != null) {
// 假设CSV格式为: id,name,value
String[] parts = line.split(",");
if (parts.length >= 3) {
String key = "user:" + parts[0];
pipeline.hset(key, "name", parts[1]);
pipeline.hset(key, "value", parts[2]);
batchCount++;
totalCount++;
// 每BATCH_SIZE条数据执行一次，避免客户端内存压力过大
if (batchCount == BATCH_SIZE) {
try {
// 带重试的Pipeline执行
for (int retry = 0; retry < 3; retry++) {
try {
pipeline.sync();
break;
} catch (JedisConnectionException e) {
if (retry == 2) throw e;
Thread.sleep(100 * (retry + 1)); // 指数退避
}
}
System.out.println("Imported " + totalCount + " records...");
pipeline = jedis.pipelined();
batchCount = 0;
} catch (JedisException e) {
System.err.println("异常: " + e.getMessage());
// 实际生产环境可能需要记录失败数据
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.err.println("异常: " + e.getMessage());
}
}
}
}
// 处理剩余的数据
if (batchCount > 0) {
try {
pipeline.sync();
} catch (JedisException e) {
System.err.println("异常: " + e.getMessage());
}
}
long endTime = System.currentTimeMillis();
System.out.println("Import completed. Total " + totalCount +
" records in " + (endTime - startTime) + "ms");
}
}
}
这个例子展示了如何使用 Pipeline 批量导入数据，并且每导入 1000 条数据就执行一次，避免一次性发送过多命令导致内存压力过大。还添加了重试机制，提高生产环境的稳定性。
Pipeline 调优优化建议
要在生产环境中高效使用 Pipeline，以下几点建议能帮你避开常见问题：
-
客户端内存监控：通过
Runtime.getRuntime().freeMemory()监控 Pipeline 执行前后的内存变化，避免 OOM。 -
服务端慢日志：开启 Redis 慢日志（
slowlog-log-slower-than 1000），排查 Pipeline 中是否存在耗时命令。 -
批量大小动态调整：根据网络 RTT 自动调整批次大小（如 RTT=10ms 时，批次大小设为 1000 条，总延迟约 10ms+命令处理时间）。
-
跨语言兼容性：Pipeline 是 Redis 协议级特性，支持所有主流 Redis 客户端（如 Python 的
pipeline()、Go 的Pipeline()），实现原理类似，具体 API 可参考各客户端文档。
Pipeline 的注意事项和局限性
虽然 Pipeline 能显著提升性能，但使用时也需要注意一些限制：
- 内存消耗：Pipeline 会在客户端缓存所有命令和结果，所以不要一次性执行过多命令，可能导致客户端内存压力。
- 单次 Pipeline 的命令条数建议控制在 100-1000 条（根据网络带宽和客户端内存调整）
- 对大批次操作，采用分页处理（如每 1000 条执行一次
pipeline.sync()）
-
非原子性：Pipeline 中的所有命令不是原子执行的，中间可能穿插其他客户端的命令。Pipeline 内的命令在 Redis 服务端按接收顺序执行，但整体操作不具备原子性。
-
与其他功能的结合：Pipeline 可以与 Redis 的事务、Lua 脚本结合使用，进一步提升性能。
Pipeline 与事务对比
| 特性 | Pipeline | 事务（MULTI/EXEC） |
|---|---|---|
| 原子性 | 不保证（逐条执行） | 保证（整体成功/失败） |
| 错误处理 | 继续执行，返回单条错误 | 命令入队时错误则回滚 |
| 阻塞性 | 无（异步批量处理） | 有（EXEC 时阻塞其他操作） |
| 性能 | 极高（仅 1 次 RTT） | 较高（2 次 RTT+命令排队） |
| 适用场景 | 非事务性批量操作 | 需原子性的批量操作 |
graph LR
A[Pipeline] --> B[优点]
A --> C[限制]
B --> D[减少网络往返RTT]
B --> E[提升吞吐量]
B --> F[批处理高效]
C --> G[非原子操作]
C --> H[客户端内存消耗]
C --> I[不适合需要前值的命令序列]
- 错误处理：Pipeline 中某个命令出错不会影响其他命令的执行，所有命令都会被处理，出错的命令会返回错误信息。
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Response;
import redis.clients.jedis.exceptions.JedisDataException;
import java.util.List;
public class PipelineErrorHandling {
public static void main(String[] args) {
try (Jedis jedis = new Jedis("localhost", 6379)) {
Pipeline pipeline = jedis.pipelined();
// 正常命令
pipeline.set("key1", "value1");
// 错误命令 - 参数不足
pipeline.hset("key2", "field1"); // 缺少value参数
// 正常命令
pipeline.set("key3", "value3");
// 使用syncAndReturnAll获取所有结果，包括错误
List<Object> results = null;
try {
results = pipeline.syncAndReturnAll(); // 即使有错误命令，也会继续执行
} catch (Exception e) {
System.out.println("Pipeline执行出错，但部分命令可能已成功执行");
}
// 遍历结果判断成功/失败
if (results != null) {
for (int i = 0; i < results.size(); i++) {
Object result = results.get(i);
if (result instanceof Exception) {
System.err.println("命令 " + i + " 失败: " + ((Exception) result).getMessage());
} else {
System.out.println("命令 " + i + " 成功: " + result);
}
}
}
// 验证正常命令是否执行成功
System.out.println("key1: " + jedis.get("key1"));
System.out.println("key3: " + jedis.get("key3"));
// 清理测试数据
jedis.del("key1", "key2", "key3");
}
}
}
如何在分布式环境中使用 Pipeline
在使用 Redis 集群或分片环境中使用 Pipeline 时需要特别注意，因为 Pipeline 中的命令必须发送到同一个 Redis 节点才能正常工作。有几种处理方法：
-
按节点分组命令：预先计算每个键所在的节点，然后对每个节点创建单独的 Pipeline。
-
使用客户端分片功能：一些 Redis 客户端（如 Lettuce）提供了分片 Pipeline 支持，能自动将命令路由到正确的节点。
-
使用 Lua 脚本：将多个操作封装在 Lua 脚本中，确保脚本在单一节点上执行。
Pipeline 与 Lua 脚本的选择
若批量操作需逻辑处理（如根据前一个命令的结果决定后续操作），建议使用 Lua 脚本；若仅需无逻辑的批量命令，Pipeline 更高效（无需脚本解析开销）。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisClusterConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
@Service
public class ClusterPipelineService {
@Autowired
private RedisConnectionFactory connectionFactory;
@Autowired
private RedisTemplate<String, String> redisTemplate;
/**
* 计算key对应的slot（兼容Jedis集群的slot算法）
*/
private static int calculateSlot(String key) {
int start = key.indexOf('{');
int end = key.indexOf('}', start);
String slotKey = (start != -1 && end != -1 && start < end) ? key.substring(start + 1, end) : key;
// CRC16(key) % 16384
return org.springframework.data.redis.connection.ClusterSlotHashUtil.calculateSlot(slotKey);
}
/**
* 在集群环境中按节点执行Pipeline
*/
public void executeClusterPipeline() {
RedisClusterConnection clusterConnection = connectionFactory.getClusterConnection();
try {
// 按照相同slot的key分组
Map<String, String> slotGroup1 = new HashMap<>(); // 假设这组key在同一个slot
for (int i = 0; i < 100; i++) {
String key = "{group1}:key" + i; // 使用{}确保同一slot
slotGroup1.put(key, "value" + i);
}
Map<String, String> slotGroup2 = new HashMap<>(); // 假设这组key在另一个slot
for (int i = 0; i < 100; i++) {
String key = "{group2}:key" + i; // 使用{}确保同一slot
slotGroup2.put(key, "value" + i);
}
// 计算第一组key所在的slot，找到对应节点
if (!slotGroup1.isEmpty()) {
String sampleKey = slotGroup1.keySet().iterator().next();
int slot = calculateSlot(sampleKey);
RedisNode node = clusterConnection.clusterGetNodeForSlot(slot);
if (node != null) {
clusterConnection.setNodeSerializer(redisTemplate.getStringSerializer());
clusterConnection.openPipeline(node);
slotGroup1.forEach((key, value) -> {
clusterConnection.stringCommands().set(key.getBytes(), value.getBytes());
});
clusterConnection.closePipeline();
} else {
System.err.println("未找到slot " + slot + " 对应的节点，跳过该批次");
}
}
// 计算第二组key所在的slot，找到对应节点
if (!slotGroup2.isEmpty()) {
String sampleKey = slotGroup2.keySet().iterator().next();
int slot = calculateSlot(sampleKey);
RedisNode node = clusterConnection.clusterGetNodeForSlot(slot);
if (node != null) {
clusterConnection.setNodeSerializer(redisTemplate.getStringSerializer());
clusterConnection.openPipeline(node);
slotGroup2.forEach((key, value) -> {
clusterConnection.stringCommands().set(key.getBytes(), value.getBytes());
});
clusterConnection.closePipeline();
} else {
System.err.println("未找到slot " + slot + " 对应的节点，跳过该批次");
}
}
} catch (Exception e) {
System.err.println("异常: " + e.getMessage());
} finally {
if (clusterConnection != null) {
clusterConnection.close();
}
}
}
/**
* 使用Lua脚本在集群环境中执行批量操作
*/
public void executeBatchWithLuaScript() {
// 假设所有操作涉及的key都有相同的前缀，确保它们在同一个slot上
String luaScript =
"for i=1,100 do " +
" -- KEYS[1]：第一个key参数（前缀），ARGV[1]：第一个参数值" +
" redis.call('SET', KEYS[1]..i, ARGV[1]..i) " +
"end " +
"return 'OK'";
try {
Object result = redisTemplate.execute((RedisCallback<Object>) connection -> {
return connection.eval(
luaScript.getBytes(),
1, // 只有一个key前缀
"{prefix}:".getBytes(), // KEYS[1]，使用大括号包裹前缀，确保所有key属于Redis集群的同一slot
"value".getBytes() // ARGV[1]
);
});
System.out.println("Lua脚本执行结果: " + result);
} catch (Exception e) {
System.err.println("异常: " + e.getMessage());
}
}
}
总结
| 特性 | 普通 Redis 操作 | Pipeline 操作 |
|---|---|---|
| 网络往返次数 | 每个命令一次 | 所有命令只有一次 |
| 执行速度 | 慢（受网络延迟影响大） | 快（可提升 10-100 倍） |
| 内存消耗 | 低 | 较高（单次建议 100-1000 条命令） |
| 原子性 | 单命令原子 | 非原子（可结合事务实现原子性） |
| 错误处理 | 立即返回错误 | 继续执行，最后返回所有错误 |
| 使用场景 | 少量命令、需要即时响应 | 大批量命令、导入导出数据 |
| 集群支持 | 完全支持 | 需要额外处理（同 slot 或分节点） |
| 实现难度 | 简单 | 稍复杂（需要管理 Pipeline 生命周期） |
