A cache is typically placed between the application and the database.
Read Request
|
v
+---------+ +---------+ +-----------+
| Client |-->| App |-->| Cache |
+---------+ +---------+ +-----------+
| |
| Cache Miss |
v |
+-------------+ |
| Database |<---+
+-------------+
However, every strategy introduces trade-offs related to consistency, performance, and complexity.
This article discusses the four most common caching strategies: Cache Aside, Read Through, Write Through and Write Back (Write Behind).
1. Cache Aside (Lazy Loading)
Cache Aside is the most commonly used caching strategy. The application communicates directly with both the cache and the database.Reading Data
The application first attempts to retrieve the requested data from the cache.If the data is not present, it is fetched from the database, stored in the cache for future requests, and then returned to the client.
Read Request
|
v
+-----------+
| Cache |
+-----------+
| |
Hit ----+ +---- Miss
| |
v v
Return Data Database
|
v
Store in Cache
|
v
Return Data
GET /customers/100customer:100SELECT * FROM customers
WHERE id = 100;
customer:100Updating Data
Updating data requires additional work. Suppose the customer's email changes.UPDATE customers
SET email='john@example.com'
WHERE id=100;
DEL customer:100Advantages
- Simple to implement- Reduces database load
- Cache stores only frequently accessed data
- Works with almost every application
Disadvantages
- First request is slower because of the cache miss- Applications must manage cache consistency
- Possibility of stale data
- Updating Data
2. Read Through Cache
In a Read Through strategy, the application communicates only with the cache. The cache itself is responsible for loading missing data from the database. Read Request
|
v
+-----------+
| Cache |
+-----------+
| |
Hit ----+ +---- Miss
| |
| v
| Database
| |
+-----------------+
Return Data
customer = cache.get("customer:100")Advantages
- Simplifies application logic- Centralizes cache management
- Automatically loads missing data
Disadvantages
- Requires cache infrastructure that supports read-through- More complex cache configuration
- Less flexible than Cache Aside
3. Write Through
In a Write Through strategy, every write updates both the database and the cache immediately.Application
|
v
+------------+
| Write Data |
+------------+
|
+-------> Cache
|
+-------> Database
customer.setEmail("john@example.com")Advantages
- Cache always contains fresh data- Very fast reads
- Simple consistency model
Disadvantages
- Every write becomes slower- Updates data even if it is never read
- Increased write overhead
Write Through is commonly used when applications perform many reads after every write.
4. Write Back (Write Behind)
In a Write Back strategy, the application writes only to the cache. The cache immediately acknowledges the write. The database is updated later.Application
|
v
+-----------+
| Cache |
+-----------+
|
|
| (Background)
v
Database
Instead, data is first written to the cache, and a background process later flushes the accumulated changes to the database.
This allows multiple updates to be combined into a single database operation.
Advantages
- Extremely fast writes- Reduces database load
- Supports high write throughput
Disadvantages
- Risk of data loss if the cache crashes before flushing- Database is temporarily stale
- Recovery mechanisms become necessary
Comparison
Different caching strategies optimize different aspects of a system. Some prioritize read performance, others focus on write throughput, while some provide stronger data consistency.The following table summarizes their key differences and common use cases.
| Strategy | Reads | Writes | Consistency | Typical Use Cases |
|---|---|---|---|---|
| Cache Aside | Fast after first read | Database first | Eventual | General web applications |
| Read Through | Fast | Database managed by cache | Eventual | Managed caching solutions |
| Write Through | Very fast | Cache + Database together | Strong | Banking, inventory, user profiles |
| Write Back | Very fast | Cache first | Eventual | Analytics, logging, gaming |
Summary
Caching reduces latency, improves throughput, and decreases database load, but the effectiveness of a cache depends on the chosen strategy.Cache Aside is the most widely adopted approach because it is simple and stores only frequently accessed data.
Read Through delegates cache loading to the cache layer, reducing application complexity.
Write Through keeps the cache and database synchronized, making it suitable for applications that require fresh cached data.
Write Back prioritizes write performance by updating the cache immediately and persisting changes to the database asynchronously, making it ideal for high-write workloads.
