Thirteen Rules for Optimizing Redis Performance

Preface

Redis

is a high‑performance in‑memory database, but it can hit bottlenecks under large data volumes; developers must follow optimization principles to unleash its full performance.

This article introduces thirteen performance‑optimization rules; following them will dramatically improve Redis performance.

1. Avoid Slow Query Commands

Slow query commands are those with high time complexity. Knowing the complexity of each Redis command is essential.

For example, when the value type is String, GET/SET are O(1). When the value type is Set, SORT and SUNION/SMEMBERS have complexities O(N+M·log(M)) and O(N) respectively, where N is the number of set elements and M is the number of elements returned by SORT.

When performance degrades, use the Redis log or the latency monitor tool to identify slow commands and replace them with more efficient alternatives.

If many slow commands exist, you can:

Replace them with more efficient commands, e.g., use SSCAN instead of SMEMBERS to iterate over a set.

Perform sorting or set‑intersection/union on the client side instead of using SORT, SUNION, SINTER on the server.

2. Disable the KEYS Command in Production

The keys command scans the entire keyspace and can block the server; it should not be used in production.

3. Set Expiration for Keys That Should Expire

Because Redis stores all data in memory, keys that have a limited lifetime should be given an expiration time so that Redis can automatically delete them.

4. Avoid Setting the Same Expiration Time for Many Keys at Once

Redis deletes expired keys in cycles (default every 100 ms). If more than 25 % of sampled keys are expired, the cycle repeats until the ratio drops below 25 %.

The parameter ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP defaults to 20, meaning roughly 200 keys are examined per second. Excessive use of EXPIREAT with identical timestamps can trigger the second rule and cause a flood of expirations, leading to blocking.

5. Choose the Appropriate Data Structure

Redis provides five core data structures: string, hash, list, set, and zset. Each has typical use‑cases, e.g., strings for simple cache values, hashes for objects with many fields, lists for ordered collections with duplicates, sets for unordered unique collections, and sorted sets for ordered collections with scores.

Redis also offers extensions such as HyperLogLog for cardinality estimation and BitMap for binary‑state tracking.

6. Review Persistence Strategy

Since Redis 4.0, three persistence options exist: AOF logging, RDB snapshots, and a hybrid AOF+RDB mode. If Redis is used only as a cache, disabling persistence or tuning it can reduce I/O pressure.

7. Use High‑Speed SSDs for Log Writes

Because AOF rewriting can be I/O‑intensive, SSDs are recommended when persistence is enabled.

8. Prefer Physical Machines Over Virtual Machines

Virtualization adds overhead. You can compare baseline performance with ./redis-cli --intrinsic-latency 120 to see that bare metal typically outperforms VMs.

9. Increase Memory or Deploy a Redis Cluster

Insufficient RAM forces the OS to swap, which dramatically slows Redis because every request must wait for disk I/O. Adding RAM or using a Redis Cluster avoids swapping and improves throughput.

10. Use Pipeline for Batch Operations

Pipeline

lets the client send multiple commands in a single round‑trip, reducing latency.

11. Optimize Client Usage

Besides pipelines, use a connection pool instead of repeatedly opening and closing connections.

12. Adopt Distributed Architecture to Boost Read/Write Speed

Redis offers master‑slave replication, Sentinel, and Redis Cluster. Clustering shards data across 16 384 slots (slot = CRC16(key) & 16383), spreading load across multiple nodes.

13. Avoid Memory Fragmentation

Frequent allocations increase fragmentation. Use INFO memory to monitor mem_fragmentation_ratio. A ratio between 1 and 1.5 is normal; above 1.5 indicates the need for defragmentation.

Conclusion

The article presents thirteen practical rules for optimizing Redis performance; applying them according to specific scenarios can significantly improve throughput and reduce latency.