Handling data with efficiency and consistency has become one of the biggest challenges of the modern age. Web applications constantly catering to high transactional data lack performance and scalability. Luckily, you can introduce caching to handle such situations, avoiding the significant cost that stems from frequent network trips.
However, while using a cache, the application has to deal with two data sources which may complicates application code and cause further performance lags. As in case of a cache miss, a network trip to the database will become necessary to get the required data and populate it into the cache. To simplify the application code and reduce the latency involved in the network trips, NCache provides a customized data source provider called Read-Through. This provider interacts with the database on behalf of your application to fetch the required data from the data source and populate the cache in single operation for present and future use.
What is Read-Through?
Read-Through is a customized data source provider, through which you tell the cache how and when it needs to get data from the database. Read-Through interacts with your data source on behalf of your application and will save it from making runtime database trips, hence, improving the application’s performance.
Figure 1: Read-Through Caching
Using Read-Through with NCache
In Read-Through Caching, when there is a cache miss, NCache will call your provider to load data on the get call. In clustered caches, where multiple servers are involved, the ReadThrough provider will activate (initialize), on all cache server nodes. However, Read-Through operations will be performed according to the topology used.
Along with ReadThrough, NCache also provides the option of forced Read-Through. With forced Read-Through enabled, your provider will ignore the data in the cache and will forcefully fetch the data from the data source. Therefore, the data will not be checked in the cache and will be fetched directly from the data source.
NCache provides multiple ways to keep your cache fresh and data expiration is one of them. But expiration alone can cause performance lags, and this is where Read-Through comes in. For example, in an e-commerce store, hundreds of products are cached, some of them are accessed frequently -the rest of the cached items will only sit there and eat up cache memory.
Figure 2: Using Read-Through with NCache
By using expiration, you can invalidate the item after a specified time or the frequency with which it has been accessed. However, there can be a possibility that an item has eventually expired, but the application requests that very item. In such a case, the application has to fetch the item from the database and then add it to the cache. This runtime database trip can lead to certain delays – thus, hurting the application’s performance.
To avoid this performance lag, Read-Through along with the ResyncOptions property will automatically fetch every item configured with the resync flag, at the moment when it expires from the cache. This will always keep the cache fresh, reduce cache misses, and avoid runtime database trips.
Similarly, Dependencies can also be a great way to keep the data consistent in the cache. Especially in scenarios where the user wants to keep the data synced with the database so that on every update in the corresponding data in the database, the cache is informed and automatically invalidates the respective data. This way the data in the cache remains fresh and all operations utilize the updated data set.
Significance of Read-Through
The following circumstances in particular should encourage you to use the Read-Through data source providers:
Simplified Application Code
Read-Through implements application code with the “Separation of Concerns” principle, to achieve this simplification. After deploying the Read-Through, all the communication with the database takes place through the data access layer. It is now the cache’s responsibility to provide the required data and synchronize the cache with the database.
Improved Read-Scalability
This feature with ResyncOptions Property also improves the read scalability by always keeping the cache item available and updated. There can be many situations where a cache item expires and the database faces countless requests from user threads.
This situation, coupled with the millions of cached items and thousands of parallel user requests, leads to a noticeably higher load on the database. Fortunately, Read-Through along with ResyncOptions keeps the cache item in the cache while it is fetching the latest copy of it from the database, it then updates the cache item, hence saving the application from going to the database for these cache items, keeping the database load to a minimum.
High Data Availability and Consistency in Cache
Read-Through ensures high data availability and consistency in the cache by automatically refreshing the cache. NCache Read-Through provider specified with ResyncOptions reloads the object immediately after its expiration or any other change in the corresponding data in the database. This prevents cache data from ever going stale.
Ways to Optimize Performance using Read-Through
Read-Through not only keeps your cache consistent but also enhances your application’s performance by allowing you to get cache items in bulk, hence saving costly database calls and network trips.
Moreover, Read-Through can be an excellent alternative to cache aside. In cache aside, the application fetches data from the data source and updates the cache, which increases the application’s responsibility, complicates the application code, and hurts the application’s performance.
Conclusion
NCache’s Read-Through data source provider enhances your application’s performance and ensures high data availability. Read-Through also simplifies your application code by eliminating code chunks for communicating with the data source, and it interacts with the database on behalf of your application. So, if you want evergreen cache data, do not hesitate to get NCache’s 60 days free trial.
