BestHub
Sign in
Tagged articles
34 articles
Page 1 of 1
Java Baker
Java Baker
Sep 15, 2025 · Backend Development

Choosing the Right Cache Update Pattern: Cache‑Aside, Write‑Back, Read‑Through

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.

Consistencycache-asidecaching
0 likes · 9 min read
Choosing the Right Cache Update Pattern: Cache‑Aside, Write‑Back, Read‑Through
macrozheng
macrozheng
Jul 3, 2025 · Backend Development

How Long Should the Delay Be in Delayed Double Delete? A Deep Dive into Cache Consistency

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 ConsistencyDelayed Double Deletecache-aside
0 likes · 13 min read
How Long Should the Delay Be in Delayed Double Delete? A Deep Dive into Cache Consistency
Cognitive Technology Team
Cognitive Technology Team
May 14, 2025 · Backend Development

Cache and Database Consistency: Strategies for Updating Order

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.

CacheConsistencycache-aside
0 likes · 6 min read
Cache and Database Consistency: Strategies for Updating Order
Tencent Cloud Developer
Tencent Cloud Developer
Nov 7, 2024 · Backend Development

Cache Consistency Strategies and Best Practices for the Cache‑Aside Pattern

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 ConsistencyDistributed Systemscache-aside
0 likes · 20 min read
Cache Consistency Strategies and Best Practices for the Cache‑Aside Pattern
Lobster Programming
Lobster Programming
Apr 20, 2024 · Backend Development

Why Cache Aside Can Fail: Hidden Risks and the Double-Delete Fix

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.

Data Consistencybackend-developmentcache-aside
0 likes · 3 min read
Why Cache Aside Can Fail: Hidden Risks and the Double-Delete Fix
Laravel Tech Community
Laravel Tech Community
Feb 5, 2024 · Backend Development

Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices

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 ConsistencyDesign Patternscache-aside
0 likes · 7 min read
Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices
Architect
Architect
Jan 30, 2024 · Backend Development

How to Keep MySQL and Redis in Sync: Practical Cache Consistency Patterns

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 Consistencycache-aside
0 likes · 9 min read
How to Keep MySQL and Redis in Sync: Practical Cache Consistency Patterns
Selected Java Interview Questions
Selected Java Interview Questions
Jan 29, 2024 · Databases

Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices

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 Consistencycache-aside
0 likes · 9 min read
Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices
Architecture & Thinking
Architecture & Thinking
Aug 30, 2023 · Backend Development

How to Ensure Cache‑Database Consistency: Strategies, Pitfalls, and Best Practices

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 ConsistencyDatabase Synchronizationcache-aside
0 likes · 18 min read
How to Ensure Cache‑Database Consistency: Strategies, Pitfalls, and Best Practices
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 5, 2023 · Databases

Mastering Cache Consistency: Strategies to Prevent Stale Data in High‑Concurrency Systems

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 ConsistencyDistributed Systemscache-aside
0 likes · 11 min read
Mastering Cache Consistency: Strategies to Prevent Stale Data in High‑Concurrency Systems
dbaplus Community
dbaplus Community
Dec 18, 2022 · Backend Development

Mastering Cache Consistency: Strategies to Keep Redis and MySQL in Sync

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.

BinlogCache Consistencycache-aside
0 likes · 17 min read
Mastering Cache Consistency: Strategies to Keep Redis and MySQL in Sync
Tencent Cloud Developer
Tencent Cloud Developer
Nov 18, 2022 · Backend Development

Cache Consistency Strategies and Best Practices

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.

BackendConsistencyDistributed Systems
0 likes · 20 min read
Cache Consistency Strategies and Best Practices
ITPUB
ITPUB
Oct 30, 2022 · Backend Development

Avoid Stale Data: Master Cache Aside, Read‑Through, Write‑Through & Write‑Behind Strategies

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
Avoid Stale Data: Master Cache Aside, Read‑Through, Write‑Through & Write‑Behind Strategies
dbaplus Community
dbaplus Community
Sep 15, 2022 · Backend Development

How to Keep Redis Cache and MySQL Consistent: Strategies and Pitfalls

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
How to Keep Redis Cache and MySQL Consistent: Strategies and Pitfalls
Sohu Tech Products
Sohu Tech Products
Jun 8, 2022 · Databases

Cache Working Mechanisms and Consistency Solutions Using Redis

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 ConsistencyDistributed Systemscache-aside
0 likes · 18 min read
Cache Working Mechanisms and Consistency Solutions Using Redis
Top Architect
Top Architect
Jun 2, 2022 · Databases

Reasonable Strategies for Database and Cache Read/Write Consistency

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.

Consistencycache-asidedistributed-lock
0 likes · 19 min read
Reasonable Strategies for Database and Cache Read/Write Consistency
Code Ape Tech Column
Code Ape Tech Column
Feb 21, 2022 · Backend Development

Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and High‑Concurrency Queue Design

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.

ConsistencyLazy Deletioncache-aside
0 likes · 11 min read
Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and High‑Concurrency Queue Design
Java Interview Crash Guide
Java Interview Crash Guide
Aug 16, 2021 · Backend Development

When to Update Redis Cache: DB‑First vs Cache‑First Strategies Explained

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 Consistencycache-aside
0 likes · 17 min read
When to Update Redis Cache: DB‑First vs Cache‑First Strategies Explained
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 6, 2021 · Backend Development

Cache Consistency Strategies: TTL, Delayed Double Delete, Cache‑Aside, and Message‑Queue Approaches

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.

BackendCacheConsistency
0 likes · 7 min read
Cache Consistency Strategies: TTL, Delayed Double Delete, Cache‑Aside, and Message‑Queue Approaches
dbaplus Community
dbaplus Community
Feb 8, 2021 · Backend Development

Avoid Stale Data: Pitfalls and Best Practices for Cache Aside, Read‑Through, Write‑Through, and Write‑Behind

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.

BackendCacheData Consistency
0 likes · 9 min read
Avoid Stale Data: Pitfalls and Best Practices for Cache Aside, Read‑Through, Write‑Through, and Write‑Behind
Top Architect
Top Architect
Sep 17, 2020 · Backend Development

Cache Consistency Strategies: Cache‑Aside Pattern, Deleting vs. Updating Cache, and Queue‑Based Solutions for High Concurrency

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.

BackendConsistencyDistributed Systems
0 likes · 11 min read
Cache Consistency Strategies: Cache‑Aside Pattern, Deleting vs. Updating Cache, and Queue‑Based Solutions for High Concurrency
Programmer DD
Programmer DD
Sep 15, 2020 · Backend Development

Solving Distributed Cache Consistency: Cache‑Aside Pattern & Lazy Update Strategies

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.

Backend ArchitectureData Consistencycache-aside
0 likes · 11 min read
Solving Distributed Cache Consistency: Cache‑Aside Pattern & Lazy Update Strategies
Architect
Architect
Sep 9, 2020 · Backend Development

Cache Aside Pattern and Solutions for Cache‑Database Consistency in High‑Concurrency Environments

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.

ConsistencyDistributed SystemsQueue
0 likes · 11 min read
Cache Aside Pattern and Solutions for Cache‑Database Consistency in High‑Concurrency Environments
Architecture Digest
Architecture Digest
Aug 24, 2020 · Backend Development

Cache Consistency Strategies: Cache Aside Pattern, Deleting vs Updating Cache, and Queue‑Based Solutions for High Concurrency

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.

CacheConsistencyQueue
0 likes · 10 min read
Cache Consistency Strategies: Cache Aside Pattern, Deleting vs Updating Cache, and Queue‑Based Solutions for High Concurrency
Java Backend Technology
Java Backend Technology
Jul 9, 2020 · Backend Development

How to Solve Distributed Cache Consistency Issues with Lazy Updates

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.

BackendCacheConsistency
0 likes · 11 min read
How to Solve Distributed Cache Consistency Issues with Lazy Updates
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 9, 2019 · Backend Development

Mastering Cache Strategies: Avoid Pitfalls and Ensure Data Consistency

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.

Data ConsistencyDistributed SystemsPerformance Optimization
0 likes · 29 min read
Mastering Cache Strategies: Avoid Pitfalls and Ensure Data Consistency
Selected Java Interview Questions
Selected Java Interview Questions
Oct 30, 2019 · Backend Development

Common Cache Problems and Their Solutions: Avalanche, Penetration, Concurrency, and DB‑Cache Inconsistency

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-asidecache-avalanchecache-penetration
0 likes · 8 min read
Common Cache Problems and Their Solutions: Avalanche, Penetration, Concurrency, and DB‑Cache Inconsistency
Architect's Tech Stack
Architect's Tech Stack
Aug 27, 2019 · Backend Development

Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and Queue‑Based Synchronization

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.

BackendQueuecache-aside
0 likes · 11 min read
Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and Queue‑Based Synchronization
21CTO
21CTO
Jul 7, 2019 · Backend Development

How to Prevent Cache‑Database Consistency Issues in High‑Concurrency Systems

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 Consistencycache-asidehigh concurrency
0 likes · 10 min read
How to Prevent Cache‑Database Consistency Issues in High‑Concurrency Systems