<> Cache request process

Redis Cached avalanche , pierce through , Breakdown is a classic problem often encountered in daily work , Let's find out , Their solutions are mainly : Bloom filter , Distributed lock ( Write next time )

This is a simple client , Server request Redis Flow chart of , Simply put, when the user accesses the server , If the server needs to request data from the database , Go to the cache first to see if there is any , If yes, return directly , If it doesn't exist, you will go to the database to query and return , This is a normal caching process .

<> Cache avalanche

For example, the scene of a treasure , When the double 11 comes , The number of user visits is very large , So a lot of data is put into Redis Cached in , Corresponding Redis of key, And the cache expiration time is set to three hours , During the double 11 , After shopping for more than three hours , At the same time, all caches are invalidated in an instant , As a result, all requests are made to the database , The database fails to respond in time , At this time, there is no way to provide this service externally .
Simply put : User visits a treasure ,Redis Medium key Large area failure , Lead to direct communication with the database , This phenomenon is called cache avalanche .
Solution :

* Set expiration time , Let him not fail at the same time , When setting cache , Random initialization failure time , In this way, all caches will not be invalidated at the same time , Distributed as widely as possible .
* Redis Generally, it is a cluster deployment , We will focus on key Put it on different nodes , Let these hotspot caches be evenly distributed on different nodes .
* Do not set cache expiration time
* Run timed tasks , Constantly refresh the cache , When the cache is about to expire, let it be extended for three hours
<> Cache penetration

Here is a scene , For example, a hacker wants to attack our website :

The primary keys of the database are from 0 Start increment , There is no negative number , This hacker has been using id<0 To our server ,redis Of course not id, Will be to MySQL Make a request , This causes requests to continue to hit the database , because Redis No interception id<0 Data of , Directly penetrated by such illegal requests .
Simply put : Cache penetration is Redis There is no such data in the database , Generally, this is not a normal user , Are malicious users .
Solution :

* When data penetration Redis When calling the database , The null value returned by the database should also be synchronized to Redis Middle to , At least make sure it's illegal id Next request directly from Redis Returned in
* ( Hackers will change different illegal parameters ), Directly pull black ip
* ( Hackers will change ip), Verify the validity of the input parameters
* Bloom filter
<> Buffer breakdown

For example, this scene : On the double 11 , Take father Ma's shoes out for auction , The programmer put the shoe data in Redis In cache , Corresponding to one key, At auction , as one can imagine , Everyone's enthusiasm is very high , It's been going on 4 hour , This shoe cache is invalid , As a result, a large number of requests cannot query the data of this shoe , And then all of them to the database , The database fails to respond in time .
Simply put : Is to puncture a very hot spot key
Solution :

* Let cache never expire ( just so so )
The best way : Distributed lock ( Lock the database at the request step , At this time, only one thread can grab the lock , That is, only one thread can operate the database , At this time, the pressure on the database is very small , When this hotspot is queried key Later, I will write again Redis in , Other threads that did not grab the lock , Let him sleep for a few milliseconds first , Go again redis Query data in )
reflection :
A project can be divided into three stages , Preparation before launching , Preparation during project operation , Treatment measures after project downtime .
For example, before the project goes online , It can be built into a cluster :Redis colony ,MySQL colony , Own distributed cluster , In this way, a high availability cluster can be formed , The robustness of the system is enhanced .
Some problems occurred during the operation of the project , The treatment measures of current limiting and degradation can be adopted , Prevent a large number of requests from hitting the database , Make the system unavailable .

If the system really hangs up , Some alarm systems can be integrated , Even if we inform our developers , At the same time, restart the project quickly , utilize Redis of aof,rdb Persistence mechanism , To quickly recover cached data , Minimize the time when the system is unavailable