1 views collected around this technical thread.
This article explains the fundamentals of caching, enumerates various client‑side, server‑side and distributed cache types, describes common caching patterns and expiration policies, and highlights practical considerations to effectively improve web application performance and reliability.
The article details NetEase Cloud Music’s high‑concurrency cache architecture—using lazy‑load, hole‑wrapped objects for penetration protection, placeholder values for missing data, horizontal and vertical scaling with consistent hashing, and asynchronous binlog‑driven invalidation—to achieve sub‑millisecond reads for a read‑heavy, write‑light music library.
This article demonstrates how to achieve cache‑database consistency by updating MySQL first, deleting Redis cache asynchronously via Canal, publishing change events to RabbitMQ, and handling acknowledgments manually in a Spring Boot application, complete with configuration steps and troubleshooting tips.
The article analyzes three data‑level classifications, examines four cache‑database write strategies, discusses their pros and cons, and presents practical solutions such as delayed double deletion, message‑queue compensation, and binlog‑driven cache updates to maintain consistency.
This article explains why Redis client‑side caching is needed, how the tracking feature works under different modes, and what trade‑offs each mode presents for memory, CPU, and network usage, helping developers design efficient caching architectures.
Meta engineers describe the challenges of cache invalidation and consistency in large‑scale distributed systems, explain why stale caches are problematic, present their Polaris observability service and consistency‑tracking techniques, and detail how they raised TAO’s cache consistency from six‑nines to ten‑nines.
This article presents a comprehensive overview of cache optimization techniques, covering benefits and costs, update policies, granularity control, penetration and avalanche mitigation, hot‑key reconstruction, and distributed batch‑operation strategies, with practical examples using Redis and MySQL.
This article explains why caching is essential for high‑concurrency systems, analyzes the challenges of keeping database and cache data consistent, and compares five practical cache‑invalidation strategies—including write‑after‑DB, delete‑before‑write, delayed double delete, queue‑based deletion, and binlog subscription—highlighting their trade‑offs and suitable scenarios.
This article explains how caching can accelerate read/write performance and reduce backend load, analyzes its benefits and costs, discusses update strategies, granularity control, and solutions for common problems such as cache penetration, empty‑hole, avalanche, and hot‑key reconstruction, providing practical guidelines for robust backend design.
This article explains the motivation for client‑side caching, what data should be cached, and details the Redis tracking feature—including normal, broadcast, and redirect modes—while providing implementation examples and best‑practice guidelines for reducing latency and load on Redis servers.
This article examines the characteristics of Redis and Memcached as distributed cache solutions, outlines common design pitfalls such as consistency, cache penetration, breakdown, avalanche, and hot‑key issues, and provides practical strategies—including consistent hashing, binlog‑driven invalidation, message‑queue indexing, and lock mechanisms—to build reliable and high‑performance caching layers in backend systems.
The article examines the risks of using the dangerous FLUSHDB command in Redis, explores common alternatives like SCAN, async deletion, and expiration, and proposes a secondary‑index solution using sets and sorted sets to efficiently invalidate only the affected cache entries without blocking the service.
An order system retrieved incorrect product size data due to master‑slave database lag causing stale Redis cache, and the article explains the original flawed flow, the revised solution that writes to cache during sync, and best practices for cache updates, read‑through, and QA testing.
This article examines various techniques for proactively refreshing Memcached entries before they expire, including dual‑key schemes, timestamp‑based checks, and lock‑based updates, and presents a preferred Java implementation that minimizes cache‑stampede and reduces memory overhead.