Using Multithreading in Redis: I/O Threads, Background Tasks, and Memory Allocator

Redis is a high‑performance key‑value store whose core processing is single‑threaded, but multithreading can significantly boost performance in certain scenarios. This article outlines the main multithreading use cases in Redis and provides configuration and code examples.

1. I/O Multithreading

Since Redis 6.0, an I/O multithreading feature handles network I/O, especially write operations. By setting the io-threads parameter in the configuration file, you can specify the number of I/O threads, which improves performance under high concurrency.

Configuration example: Add the following lines to redis.conf :

io-threads 4
io-threads-do-reads yes

This enables four I/O threads and allows them to process read operations.

Code example: Using the Python redis-py client, create a connection pool with the io_threads parameter:

import redis

# Create Redis connection pool
pool = redis.ConnectionPool(host='localhost', port=6379, db=0, io_threads=4)

# Create Redis client
r = redis.Redis(connection_pool=pool)

# Set a key‑value pair
r.set('key', 'value')

# Get the value
value = r.get('key')
print(value)

The example creates a pool with four I/O threads, then performs basic set and get operations.

2. Background Task Handling

Redis uses multithreading for time‑consuming background tasks such as the UNLINK command, which deletes keys asynchronously by offloading the work to a separate thread, avoiding blockage of the main thread.

Code example: Using UNLINK to delete a key asynchronously:

127.0.0.1:6379> SET mykey "Hello"
OK
127.0.0.1:6379> UNLINK mykey
(integer) 1

The delete operation runs in a background thread, leaving the main thread free.

3. Memory Allocator Background Thread

Redis employs jemalloc as its memory allocator, which can be configured with a background thread to handle memory release and defragmentation, improving memory management efficiency.

Configuration example: Add the following line to redis.conf :

jemalloc-bg-thread yes

This enables jemalloc's background thread.

4. Suitable Scenarios for Multithreading

High‑concurrency reads: Multiple threads can handle many read requests simultaneously in read‑heavy workloads.

Sharded storage: Distribute large data sets across shards and use separate threads for each shard to boost storage and read performance.

Multiple queue processing: When Redis acts as a message queue, multiple threads can process different queues in parallel, increasing throughput.

Conclusion

Redis's multithreading features mainly apply to I/O operations and background tasks. Proper configuration and usage can markedly improve performance in high‑concurrency environments, but they also increase CPU consumption, so users should balance benefits against server resources.