Types of Caching Strategies

This article deep dives into types of caching strategies and when to use each strategy

Hello all, hope you’re doing fine.

Let’s explore the following caching strategies in this edition.

1. Cache aside

2. Read through Cache

3. Write through Cache

4. Write around Cache

5. Write behind Cache

Cache aside

This read strategy is one of the most popular strategies for read-heavy applications that are okay to show some stale data to the user. This strategy provides the following good things: high service availability, low latencies and not putting extreme overload on your database instances for the reads. Example: Social Media platforms

In case cache instances become unavailable, all the read queries can be redirected to the database. However, if all reads go directly to the database, the database performance would be drastically affected causing a high increase in latencies. Thus, to avoid such a scenario, we can deploy a cluster of cache instances and read using a load balancer or gateway in front of cache instances.

Read through Cache

This read strategy is a bit different from cache-aside in a way that the application need not have responsibility to call the database. The cache provider library must handle the overhead of querying data from the database and writing it in a cache with a suitable TTL.

Both Read though Cache and Cache aside strategies do lazy loading of the data meaning store only that data which is being asked in the read requests. Both strategies are a great implementation because the master data written in the database can be of Terabyte magnitude but the data present in cache might be of only a few Gigabytes.

Write through Cache

In this write strategy, data is every time written to the cache and then synchronously updated to the database. The synchronous update of data to both the cache and the database causes an increase in latencies as well since you have to wait for the write to be successful in both storages. This strategy is purely for those purposes where you can’t afford data loss.

Write around Cache

In this write strategy, the writes are written directly to the database and there is no cache involvement at the time of writing. This is a good application for those scenarios where data is written once but read less frequently or never. This strategy can be used with either of the read-strategies Read-through or Cache-aside. The above diagram represents the write-around cache strategy combined with the cache aside read strategy.

Write behind Cache

This write strategy is very similar to the write-through cache strategy except for the fact that the data is written asynchronously to the database in the write-behind strategy. Another popular term for this strategy is the write-back strategy.

It’s very useful in write-heavy applications where you don’t have to wait for synchronous updates in the database. Since writing to the cache (in-memory database) is fast, the write latency is much faster compared to the Write-through cache. Another benefit is the bulk writes which are happening from the cache to the database which avoids I/O for each write request. If the cache instance goes down, then data may be lost permanently which is a con of this strategy.

Conclusion

It’s very important to understand that these are individual read-and-write strategies. One can be combined with another to serve reads and writes for your system. The one that is ideal for your system depends on the read-write traffic and data consistency you want to offer to your end users.

---

That’s it, folks for this edition of the newsletter. Please consider liking and sharing with your friends as it motivates me to bring you good content for free. If you think I am doing a decent job, share this article in a nice summary with your LinkedIn network and schedule a free 30-minute 1:1 with me:) Ping me on Linkedin!

Resources

Caching Strategies and how to choose one
Top Caching Strategies by Alex Xu