Designing Redis Cache for Billion‑Scale Systems: Challenges and Solutions

Cache design is a classic topic; early implementations used memcache , while modern systems favor redis . For low‑concurrency scenarios a simple RedisTemplate bean may suffice, but billion‑scale systems require deeper architectural considerations.

Understanding the Cache Knowledge Graph

Originally, caches accelerated CPU data exchange, but with the rapid growth of the Internet, any high‑speed storage medium used for data exchange is considered a cache. Key metrics, application patterns, and design tips are illustrated in the accompanying diagram.

Seven Classic Cache Problems

1. Cache Stampede (集中失效)

When many keys expire simultaneously, a surge of requests hits the database, overwhelming it. The solution is to randomize expiration times: expire = baseTime + randomOffset , spreading the load over time.

2. Cache Penetration (缓存穿透)

Requests for non‑existent keys repeatedly miss both cache and DB, causing DB overload. Solutions include storing a special placeholder for missing values or using a BloomFilter to filter out invalid keys before DB access.

3. Cache Avalanche (缓存雪崩)

If a subset of cache nodes fail, the entire cache layer can become unavailable. Using consistent hashing with a rehash strategy and deploying multiple replicas across different racks mitigates this risk.

4. Cache Hotspot (缓存热点)

Sudden spikes on a single hot key can overload a cache node. Detect hot keys with real‑time analytics (e.g., Spark ) and shard the key by appending ordered suffixes like key#01 , key#02 , distributing load across multiple nodes.

5. Large Keys (大Key)

Oversized values cause latency and network congestion. Strategies include setting size thresholds with compression, using object pooling, splitting large keys into smaller ones, and assigning appropriate TTLs.

6. Data Consistency (缓存数据一致性)

Since cache is volatile, data must stay consistent with the DB. Solutions involve retrying failed cache updates and pushing failed keys to a message queue for asynchronous compensation, or using short TTLs with self‑healing reloads.

7. Concurrent Pre‑heat (数据并发竞争预热)

When cached data expires, many threads may simultaneously query the DB, stressing it. Introducing a global lock ensures only one thread fetches from the DB and repopulates the cache, while others wait for the refreshed value.

Designing a cache governance dashboard to monitor SLA and dynamically scale hot keys can further improve reliability.

Conclusion

Effective cache design combines numerous techniques to maximize hit rates and maintain data consistency, ensuring that high‑traffic systems remain performant and resilient.