Pipeline vs individual commands performance in Redis

Introduction

Using pipelines helps send many commands to Redis at once, making it faster than sending commands one by one.

When you want to set or get many keys quickly.

When you want to reduce waiting time between your app and Redis.

When you have many commands to run and want to improve speed.

When network delays slow down individual commands.

When you want to batch commands to save time.

Syntax

Redis

redis-cli --pipe <<EOF
SET key1 value1
SET key2 value2
EOF

Pipelines send multiple commands without waiting for each reply.

This reduces network round trips and improves performance.

Examples

Individual commands sent one by one, each waits for reply before next.

Redis

redis> SET key1 value1
redis> SET key2 value2
redis> GET key1
redis> GET key2

Using redis-cli --pipe to batch and send commands together as a pipeline.

Redis

redis-cli --pipe <<EOF
SET key1 value1
SET key2 value2
GET key1
GET key2
EOF

Client-side pipeline batches commands and sends them together.

Redis

Using a Redis client pipeline feature:
pipe = redis_client.pipeline()
pipe.set('key1', 'value1')
pipe.set('key2', 'value2')
pipe.execute()

Sample Program

This example shows setting and getting keys individually and then using a pipeline to do the same faster.

Redis

# Using redis-py client
import redis
r = redis.Redis()

# Individual commands
r.set('a', '1')
r.set('b', '2')
val_a = r.get('a')
val_b = r.get('b')

# Using pipeline
pipe = r.pipeline()
pipe.set('x', '10')
pipe.set('y', '20')
pipe.execute()
val_x, val_y = r.get('x'), r.get('y')

print(val_a.decode(), val_b.decode())
print(val_x.decode(), val_y.decode())

Important Notes

Pipelines reduce network delays by sending many commands at once.

Pipelines do not provide atomicity. Use MULTI/EXEC for atomic transactions.

Using pipelines can greatly improve performance in apps with many Redis calls.

Summary

Pipelines send multiple commands together to save time.

Individual commands wait for each reply, which is slower.

Use pipelines to speed up Redis operations when possible.