Tagged articles
Cache Aside
46 articles · Page 1 of 1
This comprehensive guide explores Spring Boot's caching abstraction, detailing @Cacheable execution flow, source code internals, four consistency strategies (Cache Aside, delayed double-delete, binlog), multi-level Caffeine+Redis architecture, and eight production pitfalls with troubleshooting techniques.
@CacheableCache AsideCache Consistency
0 likes · 33 min read

This article explains four classic high-concurrency caching problems—cache penetration, breakdown, avalanche, and hot keys—their root causes, differences, and practical solutions including empty-value caching, Bloom filters, mutex locks, logical expiration, TTL jitter, multi-level caching, and cache-database consistency patterns.
Bloom FilterCache AsideCaching
0 likes · 12 min read

This article walks through designing a points system architecture, starting from a concrete scenario of consuming 80 points across two batches with retries and refunds, covering data models, idempotency keys, local transactions, cache-aside, event-driven reconciliation, scaling strategies, and evolutionary deployment phases.
Cache AsideIdempotencyPoints System
0 likes · 27 min read

This article analyzes why cache and database can become inconsistent, compares four basic cache‑update patterns, explains the delayed double‑delete technique, shows how to use MQ for retrying cache deletions, and evaluates Canal binlog subscription as a zero‑intrusion solution for strong eventual consistency.
Cache AsideCache ConsistencyCanal Binlog
0 likes · 28 min read

The article examines why the common update‑database, delete‑cache, add‑TTL workflow can still produce permanent stale data under high concurrency, explains the underlying race conditions, and compares several alternative strategies—including delete‑first, binlog‑driven invalidation, and lease‑based approaches—to help engineers choose the most reliable and low‑complexity solution for cache consistency.
CacheCache AsideConsistency
0 likes · 19 min read

The article analyzes the delayed double‑delete cache‑consistency pattern, exposing how its fixed sleep interval, thread blocking, unreliable second delete, and inability to handle concurrent writes make it unsuitable for high‑traffic systems, and it proposes safer cache‑aside alternatives.
Cache AsideCache ConsistencyConcurrency
0 likes · 7 min read

The article dissects the delayed double‑delete pattern for Redis‑MySQL consistency, exposing its hidden pitfalls—unreliable delay timing, thread‑blocking sleeps, fragile second‑delete retries, and concurrent‑write anomalies—then recommends cache‑aside and stronger alternatives for production systems.
Cache AsideCache ConsistencyConcurrency
0 likes · 7 min read


ZhiKe AIJun 19, 2026 · Backend Development
The article explains why caching is indispensable—from nanosecond‑level CPU caches to millisecond‑level disks—covers the classic pitfalls of penetration, breakdown and avalanche, and walks through consistency strategies such as Cache‑Aside, delayed double‑delete, and Canal‑based binlog syncing for high‑concurrency systems.
Cache AsideCache ConsistencyCaching
0 likes · 13 min read

Adding a cache layer without proper design can cause data inconsistency, cache breakdown, and performance volatility; this article breaks down cache patterns, eviction strategies, concurrency controls, and distributed consistency models, showing when and how to apply each for reliable high‑performance systems.
CacheCache AsideConcurrency
0 likes · 14 min read

Data synchronization problems often cause user complaints, inventory mismatches, and search gaps, but the root cause lies in application‑level design; this article explains the fundamentals, challenges, common scenarios, and evaluates five synchronization patterns—including cache‑aside, read‑through, write‑behind, binlog‑based replication, and transactional messaging—plus monitoring, reconciliation, and best‑practice guidelines.
Cache AsideConsistencyTransactional Messaging
0 likes · 28 min read

The article explains that overwhelming request rates exceed database capacity, causing exponential latency, and presents six proven cache‑design techniques—including in‑process, Redis, multi‑level, cache‑aside, write‑through/write‑behind, and edge caching—to keep Spring Boot APIs stable, fast, and cost‑effective under high load.
Cache AsideCachingCaffeine
0 likes · 12 min read

This article systematically compares four cache update patterns—cache‑aside, asynchronous write‑back, read/write‑through, and ongoing optimizations—detailing their implementation steps, suitable scenarios, advantages, drawbacks, and practical tips such as delayed double deletion and proactive cache refreshing to balance performance and consistency.
Cache AsideCachingConsistency
0 likes · 9 min read

This article explores cache‑database consistency strategies, explains strong, weak and eventual consistency, compares cache patterns such as Cache‑Aside, Read‑Through/Write‑Through and Write‑Behind, and details the delayed double‑delete technique, its optimal pause time, and alternative solutions like retry mechanisms and binlog‑based async eviction.
Cache AsideCache ConsistencyDelayed Double Delete
0 likes · 13 min read

This article examines common cache‑database consistency challenges and compares four update strategies—including write‑through, cache‑aside, and delayed double‑delete—to help backend developers choose the most suitable approach for maintaining data integrity in high‑traffic systems.
CacheCache AsideConsistency
0 likes · 6 min read

The article explains cache‑aside consistency challenges and compares four update strategies—DB‑then‑cache, cache‑then‑DB, DB‑then‑delete, and delete‑then‑DB—showing that deleting the cache after a successful DB write offers the smallest inconsistency window, while recommending TTLs, message‑queue invalidation, and multi‑key coordination for robust eventual consistency.
Cache AsideCache ConsistencyMySQL
0 likes · 20 min read

The article analyzes the challenges of keeping MySQL and Redis data consistent under high concurrency, compares four write‑order strategies, explains why they can cause stale cache data, and presents recommended solutions such as Cache‑Aside, distributed locks, message queues, and Canal‑based binlog syncing.
Cache AsideCanalData Consistency
0 likes · 11 min read

Cache Aside is a popular caching pattern that reads from cache first and writes through the database before invalidating the cache, but concurrent read‑write scenarios can cause stale data; the article explains these pitfalls and recommends the double‑delete strategy to keep cache and database consistent.
Cache AsideCachingData Consistency
0 likes · 3 min read

This article explains the relationship between MySQL and Redis, the classic cache‑consistency problem, and compares four common cache‑update patterns—delete‑then‑update, update‑then‑invalidate, read/write‑through, and write‑behind—detailing their workflows, advantages, and drawbacks.
Cache AsideCache ConsistencyMySQL
0 likes · 7 min read

This article explains why cache inconsistency occurs between MySQL and Redis, then walks through four concrete design patterns—delete‑then‑update, update‑then‑invalidate, read/write‑through, and write‑behind—detailing each step, trade‑offs, and failure scenarios to help engineers choose the most suitable approach.
BackendCache AsideCache Consistency
0 likes · 9 min read

This article explains the relationship between MySQL and Redis, discusses why cache consistency is challenging, and details four cache update design patterns—delete‑then‑update, update‑then‑invalidate, read/write‑through, and write‑behind—along with their advantages, drawbacks, and typical execution flows.
BackendCache AsideCache Consistency
0 likes · 9 min read

This article examines data consistency between Redis cache and MySQL database, explains common cache execution strategies such as Cache‑Aside, Read‑Through, Write‑Through, and Write‑Behind, analyzes four update sequences for consistency risks, and proposes solutions like delayed double‑delete, transactional guarantees, retry mechanisms, and binlog‑based cache invalidation.
Cache AsideCache ConsistencyDatabase Synchronization
0 likes · 18 min read

This article examines why cache‑database consistency problems arise under high concurrency, compares common update orders, explains delayed double‑delete and cache‑aside patterns, and presents practical solutions such as retry mechanisms, message queues, and MySQL binlog subscription to keep data synchronized.
Cache AsideCache Consistencydistributed systems
0 likes · 11 min read

This article explores the challenges of cache‑database consistency under the cache‑aside pattern, compares four cache‑update strategies, and provides practical techniques—including delayed double delete, MQ‑driven invalidation, and binlog subscription—to achieve near‑real‑time consistency while maintaining high read performance.
Cache AsideCache ConsistencyMySQL
0 likes · 17 min read

The article explains how using a Redis cache can boost read performance but introduces consistency challenges, compares four cache‑aside write strategies, and recommends the reliable “update database then delete cache” approach combined with short expiration times and asynchronous message‑queue invalidation to keep data fresh.
BackendCache AsideConsistency
0 likes · 20 min read


ITPUBOct 30, 2022 · Backend Development
This article explains common cache update patterns—Cache Aside, Read‑Through, Write‑Through, and Write‑Behind—illustrates their read/write flows, highlights typical pitfalls such as dirty data caused by wrong update order, and offers practical safeguards for maintaining data consistency in large‑scale systems.
BackendCache AsideCaching
0 likes · 8 min read

This article explains why Redis is used as a cache, outlines common consistency problems such as cache miss, penetration, and avalanche, compares cache‑aside, read‑through, write‑through and write‑behind patterns, and presents practical solutions like delayed double‑delete, retry mechanisms and binlog‑based asynchronous deletion to maintain eventual consistency between cache and database.
Cache Asidecaching strategiesdata-consistency
0 likes · 19 min read

This article explores Redis cache mechanisms, various caching patterns such as Cache‑Aside, Read‑Through, Write‑Through and Write‑Behind, analyzes consistency challenges in write operations, and presents solutions like delayed double deletion, retry mechanisms, and binlog‑based asynchronous cache invalidation to achieve eventual consistency.
Cache AsideCache ConsistencyRedis
0 likes · 18 min read

The article discusses how to achieve reasonable read/write consistency between databases and caches by emphasizing cache expiration, eventual consistency, analyzing the Cache‑Aside pattern, evaluating four update‑order options, recommending the "update‑DB‑then‑delete‑cache" approach, and suggesting async deletion via message queues and distributed locks to handle concurrency and cache breakdown.
Cache AsideConsistencydistributed-lock
0 likes · 19 min read

This article explains common cache read/write strategies—including Cache Aside, Read/Write Through, and Write Back—detailing their mechanisms, advantages, drawbacks, and suitable scenarios to help developers choose the appropriate approach for different backend workloads.
Cache AsideCachingperformance
0 likes · 15 min read

This article explains the fundamental cache‑aside pattern, why lazy cache deletion is preferred over immediate updates, analyzes simple and complex cache‑database inconsistency scenarios, and proposes a high‑concurrency queue‑based solution with practical considerations for backend systems.
Cache AsideConsistencydistributed-systems
0 likes · 11 min read

This article analyzes data consistency challenges between databases and Redis caches in high‑traffic applications, examines write order pitfalls and concurrency issues, and presents the Cache‑Aside pattern with retry and expiration strategies to achieve eventual consistency.
Cache AsideCache ConsistencyRedis
0 likes · 10 min read

This article examines the consistency challenges of using Redis as a cache, compares three update strategies—updating the database before the cache, deleting the cache before updating the database, and updating the database then deleting the cache—analyzes their pitfalls, and presents practical solutions such as delayed double‑delete, asynchronous retries, and binlog‑driven cache invalidation.
Cache AsideCache ConsistencyRedis
0 likes · 17 min read

This article examines cache consistency challenges in Redis-backed systems and compares several update strategies—including TTL, delayed double‑delete, cache‑aside, and message‑queue approaches—detailing their workflows, code examples, advantages, and drawbacks to guide backend developers toward reliable cache invalidation.
BackendCacheCache Aside
0 likes · 7 min read

This article explains why cache‑database inconsistencies occur in large systems, details the cache‑aside, read‑through, write‑through and write‑behind strategies, highlights three common pitfalls with concrete examples, and offers practical recommendations such as proper update ordering and cache expiration to ensure data freshness.
BackendCacheCache Aside
0 likes · 9 min read

This article examines cache‑database dual‑write consistency challenges, explains the Cache Aside pattern, outlines basic and complex inconsistency scenarios, and proposes a queue‑based solution with operational tips for maintaining data integrity under high concurrency.
BackendCache AsideCache Consistency
0 likes · 11 min read

The article explains how distributed cache‑aside patterns work, why deleting stale cache entries is often preferable to updating them, analyzes basic and complex cache‑database inconsistency scenarios, and proposes a JVM‑queue‑driven, single‑threaded update mechanism with practical considerations for high‑concurrency environments.
BackendCache AsideConsistency
0 likes · 11 min read

This article explains the classic Cache‑Aside pattern, analyzes common cache‑database consistency problems in high‑traffic systems, and presents practical solutions—including delete‑first updates, internal JVM queues, lazy recomputation, and routing considerations—to ensure reliable data synchronization under heavy concurrency.
Cache AsideData Consistencybackend architecture
0 likes · 11 min read

The article explains the classic Cache Aside pattern, why deleting rather than updating cache is preferred, analyzes basic and complex cache inconsistency scenarios, and proposes a queue‑based lazy update solution with practical considerations for read‑write blocking, request routing, and hotspot handling in high‑traffic systems.
Cache AsideConsistencyQueue
0 likes · 11 min read

This article explains the cache‑aside pattern, why deleting cache entries is often preferable to updating them, outlines basic and complex cache‑database inconsistency scenarios, and presents a queue‑driven approach with practical considerations for maintaining data consistency in high‑concurrency backend systems.
CacheCache AsideConsistency
0 likes · 10 min read

This article explains the Cache Aside pattern, why deleting stale cache entries is often better than updating them, and presents a queue‑based lazy‑update solution that handles simple and complex consistency problems in high‑concurrency environments while outlining practical performance considerations.
BackendCacheCache Aside
0 likes · 11 min read

The article explains the pitfalls of updating databases and caches separately, illustrates race conditions that cause data inconsistency, and introduces the Cache Aside strategy as a safer approach that reduces inconsistency by deleting stale cache entries before reads.
Cache AsideCachingData Consistency
0 likes · 4 min read

This article explains core caching concepts, common pitfalls such as cache penetration, breakdown and avalanche, presents classic update patterns like Cache‑Aside, Write‑Through and Write‑Behind, analyzes consistency challenges, and offers practical guidelines for designing robust multi‑level cache architectures.
Cache AsideCachingData Consistency
0 likes · 29 min read

This article explains typical cache issues such as cache avalanche, cache penetration, concurrent write conflicts, and database‑cache write inconsistency, and provides practical mitigation strategies including high‑availability setups, circuit breakers, placeholder values, distributed locks, double‑delete, and cache‑aside patterns.
Cache AsideDistributed Lockcache avalanche
0 likes · 8 min read

The article explains how distributed cache consistency problems arise with read‑write operations, introduces the Cache‑Aside pattern and lazy‑deletion strategy, analyzes simple and complex inconsistency scenarios, and proposes a queue‑driven, serial processing solution with practical considerations for high‑concurrency backend systems.
BackendCache AsideQueue
0 likes · 11 min read


21CTOJul 7, 2019 · Backend Development
This article explains why cache‑database double‑write introduces consistency problems, introduces the Cache‑Aside pattern and lazy‑loading strategy, and proposes a queue‑based serialization approach to safely handle updates and reads in high‑concurrency backend systems.
Cache AsideCache Consistencyhigh concurrency
0 likes · 10 min read

This article explores practical cache usage by comparing DB‑first and cache‑first approaches, discusses transaction‑based safety, cache‑aside patterns, handling high‑availability databases, local‑cache decisions, and consistency solutions among local, distributed caches and databases.
BackendCache AsideCaching
0 likes · 13 min read
