Redis中缓存雪崩、缓存穿透、缓存降级等概念的简单说明

 Redis中缓存雪崩、缓存穿透、缓存降级等概念的简单说明（言简意赅，不啰嗦）：
      1、缓存雪崩：缓存集中过期，新缓存还没能刷入进来，导致所有请求（查询）都走数据库，给数据库内存和CPU巨大压力，严重导致数据库宕机，进而造成系统崩溃。
          （1）、在并发数不是特别多的情况下，最多的解决方案是加锁排队。
            public object GetProductListNew()
            {
                const int cacheTime = 30;
                const string cacheKey = "product_list";
                const string lockKey = cacheKey;
        
                  var cacheValue = CacheHelper.Get(cacheKey);
                  if (cacheValue != null)
                  {
                      return cacheValue;
                  }
                  else
                  {
                      lock (lockKey)
                      {
                          cacheValue = CacheHelper.Get(cacheKey);
                          if (cacheValue != null)
                          {
                                return cacheValue;
                          }
                          else
                          {
                              cacheValue = GetProductListFromDB(); //这里一般是 sql查询数据。              
                              CacheHelper.Add(cacheKey, cacheValue, cacheTime);
                          }                    
                      }
                      return cacheValue;
                 }
            } 
          （2）、加锁排队只是保护了数据库，并没有提高吞吐量，在高并发下，缓存重建期key是锁着的，导致用户等待超时。
                另一个解决方法是：给每一个缓存数据增加相应的缓存标记，记录缓存是否失效，如果缓存失效，从新刷入缓存。
                public object GetProductListNew()
                {
                    const int cacheTime = 30;
                    const string cacheKey = "product_list";
                    //缓存标记。
                    const string cacheSign = cacheKey + "_sign";
        
                    var sign = CacheHelper.Get(cacheSign);
                    //获取缓存值
                    var cacheValue = CacheHelper.Get(cacheKey);
                    if (sign != null)
                    {
                        return cacheValue; //未过期，直接返回。
                    }
                    else
                    {
                        CacheHelper.Add(cacheSign, "1", cacheTime);
                        ThreadPool.QueueUserWorkItem((arg) =>
                        {
                            cacheValue = GetProductListFromDB(); //这里一般是 sql查询数据。
                            CacheHelper.Add(cacheKey, cacheValue, cacheTime*2); //过期时间设缓存时间的2倍，用于脏读。                
                        });
            
                        return cacheValue;
                    }
                } 
                
                
        缓存标记：记录缓存数据是否过期，如果过期会触发另外的线程在后台去更新实际key的缓存。
        缓存数据：数据的过期时间是缓存标记的过期时间的2倍，当缓存标记key过期后，实际缓存还能把旧数据返回给用户，直到另外的线程在后台更新完缓存后，才返回新缓存的数据。
          
        设置缓存时候，尽量设置为一个随机的过期时间，尽量避免大量的缓存设置相同的过期时间，避免集中过期。
   
  2、缓存穿透
        这其实就是缓存命中率问题：用户查找的信息（例：id），在数据库中不存在，缓存中更没有。这就造成，每次都去数据库查一次，然后返回空。
        解决办法就是：如果查询数据库为空，直接设置一个默认的缓存值到缓存，这样再访问这个数据的时候，直接返回默认值，不会再访问数据库了。对需要查询的key进行预先的校验，校验通过的再放行给后面的正常的缓存处理逻辑。
        
        public object GetProductListNew()
        {
            const int cacheTime = 30;
            const string cacheKey = "product_list";

            var cacheValue = CacheHelper.Get(cacheKey);
            if (cacheValue != null)
                return cacheValue;
            
            cacheValue = CacheHelper.Get(cacheKey);
            if (cacheValue != null)
            {
                return cacheValue;
            }
            else
            {
                cacheValue = GetProductListFromDB(); //数据库查询不到，为空。
            
                if (cacheValue == null)
                {
                    cacheValue = string.Empty; //如果发现为空，设置个默认值，也缓存起来。                
                }
                CacheHelper.Add(cacheKey, cacheValue, cacheTime);
            
                return cacheValue;
            }
        }    
  3、缓存预热
        所谓预热，就是在用户使用之前，把需要缓存的数据，先缓存到缓存系统。
        操作方法：
           (1)、写个刷缓存的程序，上线前，手动刷一下。
           (2)、访问量低谷时定期定时刷缓存（凌晨3点-4点）。
  4、缓存更新
        (1)、访问量低谷时定期定时刷缓存凌晨3点-4点）。        
        (2)、当有用户请求时，再去判断是否过期，过期的话，再更新缓存。 
  5、缓存降级
        (1)、缓存降级：核心就是弃车保帅，保证核心服务可用，降级可以丢弃的服务，可以让程序实施自动降级，也可以人工紧急降级。
  6、分布式缓存系统的问题
        (1)、缓存系统与底层数据库的一致性。底层系统是可读可写时，很重要。
        (2)、缓存分层时候，不同层缓存的一致性。例如：全局缓存，二级缓存，全局缓存可以有二级缓存来组成。
        (3)、多个缓存副本的一致性。缓存系统背后往往是两套缓存系统（如memcached、redis等）。
  7、缓存淘汰：
        (1)、定时定期去清理过期的缓存。
        (2)、用户请求时再去更新缓存。
  8、缓存算法（缓存满了时候，那种缓存先淘汰）
        (1)、FIFO算法，先进先出。先缓存，先被淘汰。
        (2)、LFU算法，最不经常使用算法。 
        (3)、LRU算法，近期最少使用算法。
        
  备注： 根据博客和《深入理解redis》一书理解和整理。