Redis io-threads Explained: Improving Network I/O Performance

Introduction

The io-threads directive controls the number of worker threads Redis uses for network I/O.

For many years, Redis processed both network I/O and command execution using a single thread. Starting with Redis 6, multiple I/O threads can be used to improve the handling of network traffic while command execution remains single-threaded.

This feature can improve throughput on servers with many CPU cores and large numbers of concurrent client connections.

This guide explains how io-threads works, when to enable it, and recommended settings for production systems.

Default Value

The default configuration is:

io-threads 1

A value of 1 means Redis uses a single thread for network I/O.

Syntax

io-threads

Examples:

io-threads 2

io-threads 4

io-threads 8

How io-threads Work

Redis separates two types of work:

Network I/O – Receiving requests from clients and sending responses.

Command Execution – Processing Redis commands such as GET, SET, and HSET.

When io-threads is greater than 1, multiple threads handle network communication, while a single main thread still executes commands.

This design improves network throughput without changing Redis's core execution model.

Enable I/O Threads

Open the Redis configuration file.

sudo nano /etc/redis.conf

Locate:

io-threads 1

Example:

io-threads 4

Restart Redis.

sudo systemctl restart redis

Optional: Enable Threaded Reads

Redis also supports:

io-threads-do-reads yes

When enabled, worker threads handle both reading client requests and writing responses.

By default:

io-threads-do-reads no

For many deployments, leaving this option disabled is appropriate unless benchmarking shows a benefit.

Verify the Configuration

Run:

redis-cli CONFIG GET io-threads

Example output:

1) "io-threads"

2) "4"

Choosing the Right Value

| CPU Cores | Suggested Setting           |
| --------- | --------------------------- |
| 2         | 1                           |
| 4         | 2                           |
| 8         | 4                           |
| 16        | 8                           |
| 32+       | Benchmark before increasing |

More threads are not always better. The optimal value depends on workload, CPU resources, and network traffic.

When Does io-threads Help?

I/O threads are most beneficial for:

Thousands of concurrent client connections.

High network throughput.

Multi-core servers.

Read-heavy workloads.

You may see little improvement if:

Redis is CPU-bound by command execution.

The workload consists of complex commands.

Client concurrency is low.

Common Mistakes

Assuming Redis Becomes Fully Multithreaded

Only network I/O is parallelized.

Redis command execution remains single-threaded.

Using Too Many Threads

Setting:

io-threads 32

on a small server may increase scheduling overhead without improving performance.

Skipping Benchmarking

Always measure performance before and after changing io-threads.

The ideal configuration varies by workload.

Best Practices

Leave the default setting for small servers.

Enable I/O threads only on systems with multiple CPU cores.

Benchmark before increasing the thread count.

Monitor CPU utilization and network throughput.

Keep command execution efficient to maximize the benefit of I/O threads.

Related Articles

Redis Explained

Redis maxclients Explained

Redis timeout Explained

Redis slowlog Explained

Redis tcp-keepalive Explained

Conclusion

The io-threads directive allows Redis to use multiple threads for network I/O, improving scalability on multi-core systems with many concurrent client connections. However, it does not make Redis fully multithreaded, as command execution continues to run on a single main thread.

For most deployments, the default configuration is sufficient. On high-traffic production servers, carefully tuning io-threads and validating the results through benchmarking can improve network performance and overall throughput.