当前位置:网站首页>Do you know all four common cache modes?

Do you know all four common cache modes?

2022-07-07 18:57:00 JAVA Chinese community

summary

In the system architecture , Caching is one of the easiest ways to provide system performance , Students with a little development experience will inevitably deal with caching , At least I have practiced .

If used properly , Caching can reduce response time 、 Reduce database load and save cost . But if the cache is not used properly , There may be some inexplicable problems .

In different scenarios , The caching strategy used also varies . If in your impression and experience , Caching is just a simple query 、 update operation , Then this article is really worth learning .

ad locum , Explain systematically for everyone 4 Three cache modes and their usage scenarios 、 Process and advantages and disadvantages .

Selection of caching strategy

In essence , Caching strategy depends on data and data access patterns . let me put it another way , How data is written and read .

for example :

  • Does the system write more and read less ?( for example , Time based logging )

  • Whether the data is written only once and read many times ?( for example , User profile )

  • Is the returned data always unique ?( for example , Search for )

Choosing the right caching strategy is the key to improving performance .

There are five common cache strategies :

  • Cache-Aside Pattern: Bypass caching mode

  • Read Through Cache Pattern: Read penetration mode

  • Write Through Cache Pattern: Write through mode

  • Write Behind Pattern: Also called Write Back, Asynchronous cache write mode

The above cache strategy is divided based on the data reading and writing process , Under some caching strategies, the application only interacts with the cache , Under some caching strategies, applications interact with caches and databases at the same time . Because this is an important dimension of strategy division , Therefore, you need to pay special attention to the following process learning .

Cache Aside

Cache Aside Is the most common caching mode , Applications can talk directly to caches and databases .Cache Aside It can be used for read and write operations .

Read operations Flow chart of :

4688635e863ecd7ebc182e4be3f76e39.jpeg
Cache Aside Pattern

The process of reading operation :

  • The application receives a data query ( read ) request ;

  • Whether the data that the application needs to query is in the cache :

    • If there is (Cache hit), Query the data from the cache , Go straight back to ;

    • If it doesn't exist (Cache miss), Then retrieve data from the database , And stored in the cache , Return result data ;

Here we need to pay attention to an operation boundary , That is, the database and cache operations are directly operated by the application .

Write operations Flow chart of :

e5a760ebde1d3104ee91d11cae817d03.jpeg
Cache Aside Pattern

The write operation here , Including the creation of 、 Update and delete . When writing operations ,Cache Aside The pattern is to update the database first ( increase 、 Delete 、 Change ), Then delete the cache directly .

Cache Aside Patterns can be said to apply to most scenarios , Usually in order to deal with different types of data , There are also two strategies to load the cache :

  • Load cache when using : When you need to use cached data , Query from the database , After the first query , Subsequent requests get data from the cache ;

  • Preload cache : Preload the cache information through the program at or after the project starts , such as ” National Information 、 Currency information 、 User information , News “ Wait for data that is not often changed .

Cache Aside It is suitable for reading more and writing less , For example, user information 、 News reports, etc , Once written to the cache , Almost no modification . The disadvantage of this mode is that the cache and database double write may be inconsistent .

Cache Aside It is also a standard model , image Facebook This mode is adopted .

Read Through

Read-Through and Cache-Aside Very similar , The difference is that the program doesn't need to focus on where to read data ( Cache or database ), It only needs to read data from the cache . Where the data in the cache comes from is determined by the cache .

Cache Aside The caller is responsible for loading the data into the cache , and Read Through The cache service itself will be used to load , So it is transparent to the application side .Read-Through Its advantage is to make the program code more concise .

This involves the application operation boundary problem we mentioned above , Look directly at the flow chart :

319da81c16f77817d86d0c97f52b0b2c.jpeg
Read Through

In the above flow chart , Focus on the operations in the dotted box , This part of the operation is no longer handled by the application , Instead, the cache handles it itself . in other words , When an application queries a piece of data from the cache , If the data does not exist, the cache will load the data , Finally, the cache returns the data results to the application .

Write Through

stay Cache Aside in , The application needs to maintain two data stores : A cache , A database . This is for applications , It's a little cumbersome .

Write-Through In mode , All writes are cached , Every time you write data to the cache , The cache will persist the data to the corresponding database , And these two operations are completed in one transaction . therefore , Only if you succeed in writing twice can you finally succeed . The downside is write latency , The benefit is data consistency .

It can be understood as , Applications think that the back end is a single storage , And storage itself maintains its own Cache.

Because the program only interacts with the cache , Coding will become simpler and cleaner , This becomes especially obvious when the same logic needs to be reused in multiple places .

c2856962eb9fd04c7d8a2ad58dae5677.jpeg
Write Through

When using Write-Through when , Generally, it is used together Read-Through To use .Write-Through The potential use scenario for is the banking system .

Write-Through Applicable cases are :

  • You need to read the same data frequently

  • Can't stand data loss ( relative Write-Behind for ) Inconsistent with the data

In the use of Write-Through Special attention should be paid to the effectiveness management of cache , Otherwise, a large amount of cache will occupy memory resources . Even valid cache data is cleared by invalid cache data .

Write-Behind

Write-Behind and Write-Through stay ” The program only interacts with the cache and can only write data through the cache “ This aspect is very similar . The difference is Write-Through The data will be written into the database immediately , and Write-Behind After a while ( Or triggered by other ways ) Write the data together into the database , This asynchronous write operation is Write-Behind The biggest feature .

Database write operations can be done in different ways , One way is to collect all write operations and at a certain point in time ( For example, when the database load is low ) Batch write . Another way is to merge several write operations into a small batch operation , Then the cache collects write operations and writes them in batches .

Asynchronous write operations greatly reduce request latency and reduce the burden on the database . At the same time, it also magnifies the inconsistency of data . For example, someone directly queries data from the database at this time , But the updated data has not been written to the database , At this time, the queried data is not the latest data .

Summary

Different caching modes have different considerations and characteristics , According to the different scenarios of application requirements , You need to choose the appropriate cache mode flexibly . In the process of practice, it is often a combination of multiple modes .

debda76983f6230cfdf58b61d1839408.gif

 Previous recommendation 

93e3b44e2ea1e23a303df2975321437d.jpeg

Ensure the safety of interface data 10 Kind of plan


c875a66a0a78bb0033003b646672b401.jpeg

Talk about asynchronous programming 7 Type of implementation


136ab05620f6f81cff84f052c408ec41.jpeg

Ali ' ,SpringBoot Automated Deployment artifact !


e544aaa06ac10e089f29481e810d6e33.gif

原网站

版权声明
本文为[JAVA Chinese community]所创,转载请带上原文链接,感谢
https://yzsam.com/2022/188/202207071547270660.html