Tagged articles
Cache Consistency
89 articles · Page 1 of 1
This article explains how Spring's CacheInterceptor and TransactionInterceptor execution order causes cache-database inconsistency when cache writes occur before transaction commit, and presents solutions including explicit order configuration, TransactionAwareCacheManagerProxy, and afterCommit callbacks to ensure cache updates only reflect committed transactions.
CacheCache ConsistencyCacheInterceptor
0 likes · 12 min read

This article explains why cache inconsistency occurs between MySQL and Redis, then analyzes four update patterns—delete-then-update, update-then-invalidate, read/write-through, and write-behind—detailing their execution flows, consistency guarantees, and trade-offs to help choose the best fit for your scenario.
Cache Aside PatternCache ConsistencyData Consistency
0 likes · 9 min read

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 analyzes short-link ID generation systems, comparing Redis INCR, database auto-increment, Leaf-segment, and Snowflake approaches, covering Base62 capacity planning, segment allocation with audit tables, dual-buffer prefetching, cache consistency for immediate readability, failure recovery protocols, and observability requirements for production-grade reliability.
Cache ConsistencyDistributed Systemsbase62
0 likes · 36 min read

This article compares four Java local caching solutions — ConcurrentHashMap, Guava Cache, Caffeine, and Ehcache — detailing their features, performance characteristics, and code examples, while addressing cache consistency challenges in two-level cache architectures using MQ or Canal for synchronization.
Cache ConsistencyCachingCaffeine
0 likes · 11 min read


liandkOct 5, 2026 · Backend Development
This article systematically analyzes six root causes of production data inconsistency, details fixes for five core scenarios (inventory, orders, funds, points, cache), reveals four hidden bugs, and provides a three-layer verification system, an 8-step repair SOP, and nine ironclad rules for data high availability.
Cache ConsistencyData ConsistencyIdempotency
0 likes · 16 min read


liandkSep 24, 2026 · Backend Development
This article details eight high-frequency Redis production faults—cache penetration, breakdown, avalanche, big keys, hot keys, connection exhaustion, memory OOM, and consistency issues—providing symptoms, root causes, troubleshooting commands, solutions, and a universal SOP for rapid diagnosis and resolution.
Big KeysCache ConsistencyConnection Pool
0 likes · 14 min read

This article walks through a comprehensive case study of a provincial medical appointment platform, diagnosing slow‑query bottlenecks, proposing patient‑id + create_time composite indexes, designing read‑write separation with replication, selecting patient_id for horizontal sharding, and implementing cache‑aside strategies to ensure consistency while handling cache avalanche, penetration and thundering‑herd scenarios.
Cache ConsistencyMySQLindexing
0 likes · 30 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

This article details a production-ready multi-level caching architecture using Caffeine local cache and Redis distributed cache, covering read/write flows, consistency strategies via Pub/Sub or MQ, layered defenses against cache penetration, breakthrough, and avalanche, plus real-world pitfalls and a case study showing 75% traffic intercepted locally and 60% Redis CPU reduction.
Cache ConsistencyCaffeineMicroservices
0 likes · 16 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

This article details a production-grade Spring Boot multi-level caching architecture using Caffeine L1 and Redis L2 to solve database IO bottlenecks in read-heavy scenarios, covering consistency solutions via MQ async with idempotency, defenses against cache penetration, breakdown, and avalanche, and load test results showing 78K QPS with 5.2ms P99 latency.
Cache ConsistencyCaffeineMicrometer
0 likes · 19 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

This article presents fourteen practical scenarios covering the design, pitfalls, strategies, and implementation details of distributed caching in Spring Boot, including cache breakdown prevention, write‑through vs. write‑behind, eviction policies, negative caching, secondary caches, cache‑aside pattern, warming, monitoring, consistency, and custom key generation, all illustrated with concrete code examples.
Cache ConsistencyCache EvictionDistributed Caching
0 likes · 17 min read

At billion‑level request rates, the traditional cache‑aside pattern fails, so the article proposes a three‑layer architecture—Canal captures MySQL binlog, an MQ (RocketMQ/Kafka) buffers changes, and a coordinated local cache service updates L1 caches with short TTL, achieving high performance and eventual consistency.
Cache ConsistencyCanalRocketMQ
0 likes · 12 min read

The article dissects why the delayed double‑delete cache‑consistency pattern breaks under high traffic, illustrates Alibaba’s painful experience, and then details two production‑grade alternatives—lease‑based token control and version‑number comparison—explaining their principles, Redis‑Lua implementations, and trade‑offs.
Cache ConsistencyDelayed Double DeleteDistributed Systems
0 likes · 8 min read

The article examines the delayed double‑delete cache invalidation technique, reveals its hidden risk of cache‑penetration‑induced database load, compares Facebook's lease‑based solution and Uber's version‑number approach, and advises when the method is appropriate for high‑traffic systems.
Cache ConsistencyDelayed Double DeleteJava
0 likes · 16 min read

This article examines the common data‑consistency challenges when writing to both a database and a Redis cache, evaluates four write‑order strategies, and presents the most reliable approach—writing to the database first then deleting the cache—along with retry mechanisms using scheduled jobs, message queues, and binlog listeners.
Cache ConsistencyElastic-JobRocketMQ
0 likes · 17 min read

This article examines the double‑write consistency problem between databases and caches like Redis, explains why naïve cache‑first or DB‑first updates can cause stale or phantom data under high concurrency, and evaluates four practical solutions with detailed trade‑offs and recommended retry mechanisms.
Cache Consistencydatabasehigh-concurrency
0 likes · 17 min read

This article walks through the fundamentals and advanced techniques for guaranteeing cache consistency, covering the Double‑Check pattern, root causes of inconsistency, interview‑ready questions, practical solutions like message queues, optimistic locking, multi‑level caching, and cutting‑edge schemes such as consistent hashing with singleflight.
Cache ConsistencyMulti-level CacheOptimistic Lock
0 likes · 20 min read

This article explains why a single Redis shard cannot handle extreme traffic, introduces multi‑level caching, and compares four practical methods—MQ synchronization, Redis Pub/Sub, version‑check, and automatic refresh—to keep local caches consistent under heavy load.
BackendCache ConsistencyMQ
0 likes · 6 min read

This article analyses why cache consistency between MySQL and Redis breaks under high concurrency, explains the CAP perspective, walks through five typical failure scenarios, and presents concrete solutions such as delayed double‑delete, retry with MQ, binlog listening, expiration fallback, and mutex locks, ending with a decision guide for selecting the most suitable strategy.
BackendCache ConsistencyDistributed Systems
0 likes · 13 min read

This article walks through essential ByteDance Java interview topics, covering thread safety fundamentals, thread‑pool configuration, Redis performance tricks, Zset and skip‑list internals, memory‑policy handling, cache‑consistency patterns, and MySQL transaction ACID properties, providing code examples and best‑practice recommendations.
Cache ConsistencyJava ConcurrencyMySQL transaction
0 likes · 25 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

The article examines the benefits and hidden risks of using distributed caches, analyzes real‑world failure cases from Facebook, Google and AWS, and provides detailed strategies to mitigate availability and consistency problems through careful refresh policies, incremental updates, and compensation mechanisms.
Cache Consistencyavailability riskcache design
0 likes · 19 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 ConsistencyDistributed Systems
0 likes · 20 min read

This article examines why and how to use local in‑process caches in Java, compares four implementations—ConcurrentHashMap, Guava Cache, Caffeine, and Ehcache—covers essential cache features, consistency challenges, hit‑rate optimization, and recommends Caffeine as the most performant choice for a two‑level caching architecture.
Cache ConsistencyCaffeineConcurrentHashMap
0 likes · 11 min read

This article explains the causes of Redis cache‑database inconsistency, cache avalanche, breakdown, and penetration, and provides practical strategies such as synchronous writes, delayed double deletion, expiration tuning, circuit breaking, rate limiting, and Bloom filters to keep systems stable.
Cache Consistencycache avalanchecache penetration
0 likes · 8 min read

To maintain data consistency between Redis caches and MySQL databases, this article examines common pitfalls and presents three robust solutions—deleting cache before DB writes, updating the DB then removing cache, and implementing delete‑retry mechanisms—plus optional locking for strong consistency.
Cache ConsistencyMySQLdata synchronization
0 likes · 6 min read

This article explains why cache‑DB consistency is a long‑standing challenge, compares naive full‑load and delete‑cache approaches, analyzes concurrency and failure scenarios, and presents reliable solutions such as updating the database first followed by cache deletion using message queues or binlog subscriptions.
Cache ConsistencyDatabase Synchronizationeventual consistency
0 likes · 19 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 (Cache‑Aside), read/write‑through, and write‑behind—illustrating each with flow diagrams and practical considerations.
Cache ConsistencyCache Design PatternsMySQL
0 likes · 7 min read

This article explains how Redis as a distributed cache can cause data inconsistency with relational databases during write operations, outlines read and update workflows, compares five cache‑update strategies, and presents a delayed double‑delete solution with sample code to maintain consistency.
Backend DevelopmentCache Consistencyredis
0 likes · 6 min read

The article explains why data inconsistency occurs between MySQL and Redis under high concurrency, analyzes cache‑delete timing issues, and presents two solutions—delayed double‑delete and asynchronous cache updates via MySQL binlog—detailing implementation steps, advantages, drawbacks, and practical considerations.
Async UpdateCache Consistencybinlog
0 likes · 8 min read

This article explains the classic cache consistency problem between MySQL and Redis, analyzes why inconsistencies occur, and details four common design patterns—delete‑then‑update, update‑then‑invalidate (Cache‑Aside), Read/Write‑Through, and Write‑Behind—along with their advantages, drawbacks, and typical execution flows.
Cache ConsistencyDatabase CachingDesign Patterns
0 likes · 9 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 ConsistencyDesign Patterns
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

Redis serves as a powerful in‑memory key‑value store for distributed caching, offering various data structures, persistence options, deployment modes, eviction policies, and update strategies, while addressing consistency challenges, cache miss scenarios, and failure modes such as penetration, breakdown, and avalanche.
Cache ConsistencyCache EvictionSpring Boot
0 likes · 13 min read

The article explains how concurrent database updates can cause Redis cache inconsistency, introduces the delayed double‑delete solution, details each step of the algorithm, provides full Spring Boot AOP implementation code, demonstrates verification with test cases, and shares the complete project repository.
AOPBackend DevelopmentCache Consistency
0 likes · 11 min read

This article explains why high‑frequency database reads become a performance bottleneck, introduces common caching patterns such as Cache‑Aside, Read‑Through, Write‑Through and Write‑Behind, discusses consistency challenges, and provides practical solutions for cache penetration and avalanche scenarios.
Cache Consistencycache avalanchecache penetration
0 likes · 10 min read

This article describes how a social live‑streaming platform designed and implemented a custom multi‑level cache consistency framework, detailing the background challenges, the architecture of a cache pipeline with Zookeeper‑based node discovery and retry‑enabled execution, and the integration SDKs that enable transparent cache clearing across services.
Backend DevelopmentCacheCache Consistency
0 likes · 10 min read

This article explains Canal's background, core functions, deployment steps, and component architecture, then shows how to integrate it with Spring Boot to monitor MySQL binlog events and keep Redis cache synchronized with database changes, while also covering Canal‑admin management and limitations.
Cache ConsistencyCanalCanal-admin
0 likes · 19 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 guide walks through building a SpringBoot architecture that updates MySQL first, deletes Redis cache asynchronously via Canal and RabbitMQ, resolves common Canal meta‑data mismatches, and configures manual RabbitMQ acknowledgments to guarantee reliable cache invalidation.
Cache ConsistencyCanalMessage Queue
0 likes · 12 min read

This article explains why master‑slave replication is needed in high‑concurrency scenarios, describes the consistency challenges it introduces, and presents three practical solutions—half‑synchronous replication, database middleware, and cache‑key recording—detailing their principles, advantages, and drawbacks.
Cache ConsistencyDatabase ReplicationMySQL
0 likes · 8 min read


ITPUBJun 29, 2023 · Backend Development
This article examines the common consistency challenges between Redis cache and MySQL, explains why strict consistency is hard to achieve, and presents four practical approaches—cache‑first delete, delayed double delete, DB‑first update with lock, and MQ‑based retry—to minimize inconsistency windows and ensure reliable data synchronization.
Cache ConsistencyMySQLdata synchronization
0 likes · 9 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 explains how to design and use various client‑side, CDN, and server‑side caching techniques—including HTTP Cache‑Control, Redis data structures, cache consistency patterns, and mitigation of cache penetration, breakdown, and avalanche—to improve performance and reliability of high‑traffic distributed applications.
CDNCache ConsistencyDistributed Systems
0 likes · 23 min read

The article explains the classic cache consistency problem between MySQL and Redis, analyzes how inconsistencies arise, and details four cache‑update design patterns—delete‑then‑update, cache‑aside, read/write‑through, and write‑behind—highlighting their workflows, advantages, and drawbacks.
Backend DevelopmentCache ConsistencyDesign Patterns
0 likes · 8 min read

This article examines the challenges of keeping cache and database data synchronized, categorizes data by real‑time requirements, and evaluates four cache‑write strategies—updating the database first, deleting cache first, and their variations—highlighting their advantages, pitfalls, and practical solutions such as delayed double deletion, forced master reads, and binlog‑driven cache updates.
Cache Consistencycache invalidation
0 likes · 8 min read

This article explains how to design and use client‑side, CDN, and server‑side caches—including Redis data structures, consistency patterns, and mitigation techniques for cache breakdown, penetration, and avalanche—to achieve high performance and reliability in billion‑user distributed applications.
Cache ConsistencyDistributed Systemscache penetration
0 likes · 23 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

This article introduces the 2022 China Cloud Computing Infrastructure Developer Conference, highlights Zhang Jiachen's talk on the FUSE cache consistency model, explains the performance‑consistency trade‑off, and outlines optimization strategies and practical case studies for improving FUSE‑based storage solutions.
Cache ConsistencyCloud NativeFUSE
0 likes · 4 min read

This article examines common pitfalls and six practical strategies for maintaining data consistency between MySQL and Redis caches, comparing naive approaches with optimal solutions such as cache double‑delete, asynchronous serialization via message queues, and binlog‑driven eventual consistency, and offers recommendations for real‑time and eventual consistency scenarios.
Cache ConsistencyMessage QueueMySQL
0 likes · 8 min read

The article explains why caching is essential for high‑traffic read‑heavy services, analyzes the consistency problems that arise when data exists simultaneously in MySQL and Redis, compares four cache‑update strategies, and provides practical recommendations such as using expiration, delayed double‑delete, message queues, and binlog subscription to achieve eventual consistency.
BackendCache ConsistencyMySQL
0 likes · 18 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 ConsistencyDistributed Systems
0 likes · 18 min read

Server‑side caching improves performance by trading space for time, using local caches like HashMap, Guava, Ehcache, and Caffeine, distributed caches such as Redis, and multi‑level architectures that combine in‑process, distributed, and database layers, while employing consistency patterns, monitoring, and hot‑key detection.
Cache ConsistencyCachingCaffeine
0 likes · 16 min read

This article examines the characteristics of Redis and Memcached, identifies typical design mistakes such as consistency, cache avalanche, hot‑key, penetration and breakdown issues, and presents practical mitigation strategies—including consistent hashing, binlog‑driven cache invalidation, distributed locking, and multi‑node replication—to help backend engineers build reliable high‑concurrency cache layers.
BackendCache ConsistencyDistributed Systems
0 likes · 20 min read

The article explains why data inconsistency occurs when MySQL and Redis are used together under heavy load, analyzes cache‑delete ordering issues, and presents two practical solutions—delayed double‑delete and asynchronous cache updates via MySQL binlog—along with their trade‑offs and implementation steps.
Async UpdateCache ConsistencyMySQL
0 likes · 8 min read

This article analyzes why data inconsistencies arise when MySQL and Redis are used together under high load, compares cache‑delete ordering problems, and presents two practical solutions—delayed double‑delete and asynchronous binlog‑driven cache updates—along with implementation tips and trade‑offs.
Cache ConsistencyMySQLredis
0 likes · 8 min read

The article reviews major cache‑consistency strategies—Cache‑Aside, Read‑Through, Write‑Through, and Write‑Behind—detailing their performance and consistency trade‑offs, discusses compensation techniques such as delayed double‑delete and MySQL binlog‑based incremental parsing (DTS) for reliable deletion and HA, and advises selecting the appropriate approach based on specific business requirements.
Cache ConsistencyDistributed Systemscaching strategies
0 likes · 15 min read

In distributed e‑commerce systems, achieving Redis cache consistency requires invalidating stale entries via reliable DB change detection (e.g., binlog listeners) and optionally using versioned writes that only update when newer, combined with safeguards like TTLs, double deletes, and business‑specific designs to mitigate race conditions and ensure eventual consistency.
Backend DevelopmentCache Consistencyredis
0 likes · 9 min read


21CTODec 17, 2021 · Backend Development
This article explores how caching accelerates read/write performance and reduces backend load, analyzes its benefits and costs, and presents practical strategies for cache updates, granularity control, penetration, avalanche, and hot‑key issues with concrete examples and diagrams.
Cache ConsistencyCachingDistributed Systems
0 likes · 14 min read

This article examines common cache‑and‑database consistency approaches, compares their drawbacks, and recommends a delayed double‑delete strategy with practical code examples to keep data reliable in read‑heavy, write‑light systems.
Cache ConsistencyDelayed Double Deleteread‑write strategy
0 likes · 10 min read

This article explores the role of cache in computer architecture, covering why caches are needed, how data is placed and retrieved, various replacement policies, write strategies, and consistency protocols such as MESI, while illustrating concepts with diagrams and code examples.
CacheCache ConsistencyLRU
0 likes · 12 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 Consistencyeventual consistency
0 likes · 10 min read

This article examines the consistency challenges when using Redis as a cache for database data, compares three update strategies, and presents practical solutions such as delayed double‑delete, retry mechanisms, and handling cache penetration, avalanche, and thread‑safety issues in Java.
Cache ConsistencyConcurrencyJava
0 likes · 18 min read

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.
Cache ConsistencyMemcachedcache invalidation
0 likes · 18 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.
Backend DevelopmentCache AsideCache Consistency
0 likes · 17 min read

This article explains cache consistency problems and solutions such as double‑delete and retry mechanisms, dives into Java fundamentals like HashMap internals and thread pools, and presents several backend interview coding questions with examples and code snippets.
Backend DevelopmentCache ConsistencyHashMap
0 likes · 18 min read

By illustrating how to replace simple HashMap caching with Redis‑based distributed caches and locks—using SETNX, Lua scripts, and Redisson—the article shows Spring Boot developers how to prevent cache breakdown, ensure data consistency, and dramatically improve throughput in high‑concurrency web applications.
Cache ConsistencyCachingDistributed Systems
0 likes · 16 min read


ITPUBJun 27, 2021 · Fundamentals
This article explores the role of multi‑level caching—from distributed and local caches to direct memory and CPU cache—detailing performance gains, cache‑miss handling, consistency challenges, false sharing issues, and practical mitigation techniques such as approximate LRU, random TTL, delayed double‑delete, padding, and lock‑free designs.
CPU cacheCache ConsistencyCaching
0 likes · 13 min read


ITPUBMay 27, 2021 · Backend Development
This article examines common cache‑database consistency approaches, analyzes their drawbacks through concrete examples, compares them in a decision matrix, and proposes a reliable solution—delayed double‑delete with retry mechanisms—detailing implementation code, timing considerations, and practical deployment tips for high‑read, low‑write services.
Cache Consistencyconsistency strategiesdatabase
0 likes · 11 min read

This article examines why database caching is needed, outlines the consistency challenges of using Redis as a MySQL cache, and compares four practical solutions—from simple TTL expiration to binlog subscription—helping developers select the most suitable approach for their latency and reliability requirements.
Cache ConsistencyDatabase CachingMySQL
0 likes · 7 min read

This article examines why caching is needed for MySQL, discusses consistency challenges, and compares four Redis‑based solutions—including expiration, synchronous updates, Kafka‑mediated async updates, and binlog replication—offering guidance on selecting the appropriate approach based on latency and reliability requirements.
BackendCache ConsistencyDatabase Caching
0 likes · 9 min read

This guide compiles 21 practical Redis usage guidelines covering key naming conventions, value size limits, expiration strategies, batch operations, risky commands, distributed lock patterns, cache consistency, capacity planning, and common pitfalls like cache penetration, snowball, and hot‑key issues, helping developers and operators build reliable, high‑performance Redis deployments.
Best PracticesCache ConsistencyDistributed Lock
0 likes · 21 min read

This article explains how the creator red‑packet feature was engineered to guarantee idempotent, fault‑tolerant, and high‑throughput red‑packet claims by using multi‑level caching, empty placeholders, binlog‑driven synchronization, active cache invalidation, ordered Kafka consumption, and fallback strategies to resolve cache‑DB consistency issues.
Cache ConsistencyIdempotencyKafka
0 likes · 11 min read

This article analyzes the characteristics of Redis and Memcached, explains typical design mistakes such as inconsistent hashing, cache avalanche, penetration, and hot‑key issues, and provides practical solutions like consistent hashing, binlog‑driven cache invalidation, key versioning, and distributed locking to improve cache reliability and performance.
Cache ConsistencyHot KeyMemcached
0 likes · 22 min read

This article explains how large‑scale internet applications can use various caching patterns—Cache‑Aside, Read‑Through, Write‑Through, Write‑Behind—and mitigation techniques for consistency, stampede, penetration, jitter, and avalanche to keep databases from becoming performance bottlenecks under massive traffic spikes.
Backend PerformanceCache ConsistencyCaching
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

This article explains why database caching is essential, outlines the consistency challenges of using Redis as a MySQL cache, and compares four practical synchronization solutions—ranging from simple TTL expiration to binlog subscription—highlighting their advantages, drawbacks, and appropriate selection criteria.
Cache ConsistencyDatabase CachingMySQL
0 likes · 8 min read


ITPUBSep 6, 2020 · Databases
This article explains why caching is essential for high‑traffic MySQL applications, outlines the consistency challenges of using Redis as a cache, and compares four practical synchronization solutions—TTL‑only, write‑through, message‑queue‑based, and binlog‑driven—highlighting their advantages, drawbacks, and selection guidelines.
Cache ConsistencyDatabase CachingMessage Queue
0 likes · 10 min read

This article walks through the evolution of a Redis‑based cache layer for multi‑data‑center deployments, addressing consistency, safety, performance, disk‑space, data loops, timestamp versioning, master‑slave failover, and global numeric aggregation, and culminates in a ready‑to‑use middleware solution.
Cache ConsistencyFailoverLOGICAL_CLOCK
0 likes · 19 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

In high‑concurrency scenarios, using Redis as a buffer can improve performance, but without proper strategies such as delayed double‑delete, cache expiration, or asynchronous binlog‑driven updates, inconsistencies between Redis and MySQL may arise, so this article explains the causes and presents four practical solutions.
Backend DevelopmentCache ConsistencyMySQL
0 likes · 6 min read

This article explains how JD Daojia leverages Redis for order list storage, ensuring data consistency, implementing distributed locks, and preventing cache penetration and avalanche through lock granularity and MQ-based cache updates, with detailed Java code examples.
BackendCache ConsistencyJava
0 likes · 13 min read

This article explores multi‑level caching architectures, detailing how Nginx, local and distributed caches, and Tomcat interact, and offers practical solutions for expiration strategies, dimensional caching, load‑balancing algorithms, hot‑data handling, atomic updates, and rapid recovery from cache failures.
Cache ConsistencyCachingMulti-level Cache
0 likes · 17 min read

The article explains how proper cache usage can dramatically improve resource utilization, response time, and reliability in high‑concurrency front‑end and back‑end systems, while also addressing cache hit‑rate optimization, data consistency, and mitigation techniques for cache penetration and avalanche scenarios.
Cache ConsistencyCachingcache avalanche
0 likes · 5 min read
