How to solve redis breakdown

Breakdown: refers to a single key that cannot be found in the cache. Go to the database to query, so if the amount of data is not large or the concurrency is not large, there will be no What's the problem.

If the database data volume is large and the concurrency is high, it may cause the database to be overloaded and collapse

Note: This refers to High concurrency occurs for a single key!!! (Recommended learning: Redis video tutorial)

Solution:

1) Through the synchronized double check mechanism : A certain key only allows one thread to query, blocking other threads

In the synchronization block, continue to judge and check to ensure that it does not exist before checking the DB.

For example:

 private static volaite Object lockHelp=new Object();
   public String getValue(String key){
     String value=redis.get(key,String.class);
     if(value=="null"||value==null||StringUtils.isBlank(value){
         synchronized(lockHelp){
                value=redis.get(key,String.class);
                 if(value=="null"||value==null||StringUtils.isBlank(value){
                      value=db.query(key);
                      redis.set(key,value,1000);
                  }
            }
           }    
        return value;
   }

Disadvantages: Will block other threads

2) Set the value to never expire

This method can be said to be the most reliable and safe, but it takes up space, consumes a lot of memory, and cannot keep the data up to date. This needs to be based on specific business logic. To do

I personally think that if you want to keep the data up to date, try this. For reference only:

Start a scheduled task or use TimerTask Timing, these values ​​​​are queried and updated in the cache every period of time. Of course, the premise is that it will not cause excessive pressure on the database (this is very important)

3) Use mutual exclusion Lock (mutex key)

A common practice in the industry is to use mutex. To put it simply, when the cache fails (the value taken out is judged to be empty), instead of loading the db immediately, you first use some operations of the cache tool with a successful operation return value (such as Redis's SETNX or Memcache ADD) to set a mutex key. When the operation returns successfully, perform the load db operation and restore the cache; otherwise, retry the entire get cache method.

SETNX is the abbreviation of "SET if Not eXists", which means it is set only when it does not exist. You can use it to achieve the lock effect. Versions before redis2.6.1 did not implement the expiration time of setnx, so here are two version code references:

public String get(key) {
      String value = redis.get(key);
      if (value == null) { //代表缓存值过期
          //设置3min的超时，防止del操作失败的时候，下次缓存过期一直不能load db
          if (redis.setnx(key_mutex, 1, 3 * 60) == 1) {  //代表设置成功
               value = db.get(key);
                      redis.set(key, value, expire_secs);
                      redis.del(key_mutex);

                     return value;
              } else {  //这个时候代表同时候的其他线程已经load db并回设到缓存了，这时候重试获取缓存值即可
                      sleep(10);
                      get(key);  //重试
              }
          } else {
              return value;      
          }

}

For more Redis-related technical articles, please visit Redis database usage tutorial Column for learning!

The above is the detailed content of How to solve redis breakdown. For more information, please follow other related articles on the PHP Chinese website!