为什么大多数IP地址通常以192.168开头？

2021-03-06    分类： 网站建设

我们使用缓存的主要目是提升查询速度和保护数据库等稀缺资源不被占满。而缓存最常见的问题是缓存穿透、击穿和雪崩，在高并发下这三种情况都会有大量请求落到数据库，导致数据库资源占满，引起数据库故障。今天我主要分享一下layering-cache缓存框架在这个三个问题上的实践方案。

概念

缓存穿透

在高并发下，查询一个不存在的值时，缓存不会被命中，导致大量请求直接落到数据库上，如活动系统里面查询一个不存在的活动。

缓存击穿

在高并发下，对一个特定的值进行查询，但是这个时候缓存正好过期了，缓存没有命中，导致大量请求直接落到数据库上，如活动系统里面查询活动信息，但是在活动进行过程中活动缓存突然过期了。

缓存雪崩

在高并发下，大量的缓存key在同一时间失效，导致大量的请求落到数据库上，如活动系统里面同时进行着非常多的活动，但是在某个时间点所有的活动缓存全部过期。

常见解决方案

  • 直接缓存NULL值
  • 限流
  • 缓存预热
  • 分级缓存
  • 缓存永远不过期

layering-cache实践

在layering-cache里面结合了缓存NULL值，缓存预热，限流、分级缓存和间接的实现"永不过期"等几种方案来应对缓存穿透、击穿和雪崩问题。

直接缓存NULL值

应对缓存穿透最有效的方法是直接缓存NULL值，但是缓存NULL的时间不能太长，否则NULL数据长时间得不到更新，也不能太短，否则达不到防止缓存击穿的效果。

我在layering-cache对NULL值进行了特殊处理，一级缓存不允许存NULL值，二级缓存可以配置缓存是否允许存NULL值，如果配置可以允许存NULL值，框架还支持配置缓存非空值和NULL值之间的过期时间倍率，这使得我们能精准的控制每一个缓存的NULL值过期时间，控制粒度非常细。当NULL缓存过期我还可以使用限流，缓存预热等手段来防止穿透。

示例：

  1. @Cacheable(value = "people", key = "#person.id", depict = "用户信息缓存", 
  2.         firstCache = @FirstCache(expireTime = 10, timeUnit = TimeUnit.MINUTES), 
  3.         secondaryCache = @SecondaryCache(expireTime = 10, timeUnit = TimeUnit.HOURS, 
  4.                 isAllowNullValue = true, magnification = 10)) 
  5. public Person findOne(Person person) { 
  6.     Person p = personRepository.findOne(Example.of(person)); 
  7.     logger.info("为id、key为:" + p.getId() + "数据做了缓存"); 
  8.     return p; 
  9. } 

在这个例子里面isAllowNullValue = true表示允许换存NULL值，magnification = 10表示NULL值和非NULL值之间的时间倍率是10，也就是说当缓存值为NULL是，二级缓存的有效时间将是1个小时。

限流

应对缓存穿透的常用方法之一是限流，常见的限流算法有滑动窗口，令牌桶算法和漏桶算法，或者直接使用队列、加锁等，在layering-cache里面我主要使用分布式锁来做限流。

layering-cache数据读取流程：

数据读取流程.jpg

下面是读取数据的核心代码：

  1. private  T executeCacheMethod(RedisCacheKey redisCacheKey, Callable valueLoader) { 
  2.     Lock redisLock = new Lock(redisTemplate, redisCacheKey.getKey() + "_sync_lock"); 
  3.     // 同一个线程循环20次查询缓存，每次等待20毫秒，如果还是没有数据直接去执行被缓存的方法 
  4.     for (int i = 0; i < RETRY_COUNT; i++) { 
  5.         try { 
  6.             // 先取缓存，如果有直接返回，没有再去做拿锁操作 
  7.             Object result = redisTemplate.opsForValue().get(redisCacheKey.getKey()); 
  8.             if (result != null) { 
  9.                 logger.debug("redis缓存 key= {} 获取到锁后查询查询缓存命中，不需要执行被缓存的方法", redisCacheKey.getKey()); 
  10.                 return (T) fromStoreValue(result); 
  11.             } 
  12.  
  13.  
  14.             // 获取分布式锁去后台查询数据 
  15.             if (redisLock.lock()) { 
  16.                 T t = loaderAndPutValue(redisCacheKey, valueLoader, true); 
  17.                 logger.debug("redis缓存 key= {} 从数据库获取数据完毕，唤醒所有等待线程", redisCacheKey.getKey()); 
  18.                 // 唤醒线程 
  19.                 container.signalAll(redisCacheKey.getKey()); 
  20.                 return t; 
  21.             } 
  22.             // 线程等待 
  23.             logger.debug("redis缓存 key= {} 从数据库获取数据未获取到锁，进入等待状态，等待{}毫秒", redisCacheKey.getKey(), WAIT_TIME); 
  24.             container.await(redisCacheKey.getKey(), WAIT_TIME); 
  25.         } catch (Exception e) { 
  26.             container.signalAll(redisCacheKey.getKey()); 
  27.             throw new LoaderCacheValueException(redisCacheKey.getKey(), e); 
  28.         } finally { 
  29.             redisLock.unlock(); 
  30.         } 
  31.     } 
  32.     logger.debug("redis缓存 key={} 等待{}次，共{}毫秒，任未获取到缓存，直接去执行被缓存的方法", redisCacheKey.getKey(), RETRY_COUNT, RETRY_COUNT * WAIT_TIME, WAIT_TIME); 
  33.     return loaderAndPutValue(redisCacheKey, valueLoader, true); 
  34. } 

当需要加载缓存的时候，需要获取到锁才有权限到后台去加载缓存数据，否则就会等待(同一个线程循环20次查询缓存，每次等待20毫秒，如果还是没有数据直接去执行被缓存的方法，这个主要是为了防止获取到锁并且去加载缓存的线程出问题，没有返回而导致死锁)。当获取到锁的线程执行完成会将获取到的数据放到缓存中，并且唤醒所有等待线程。

这里需要注意一下让线程等待一定不能用Thread.sleep()，我在使用Spring Redis Cache的时候，我发现当并发达到300左右，缓存一旦过期就会引起死锁，原因是使用的是sleep方法来让没有获取到锁的线程等待，当等待的线程很多的时候会产生大量上下文切换，导致获取到锁的线程一直获取不到cpu的执行权，导致死锁。在layering-cache里面，我们使用的是LockSupport.parkNanos方法，它会释放cpu资源, 因为我们使用的是redis分布式锁，所以也不能使用wait-notify机制。

缓存预热

有效应对缓存的击穿和雪崩的方式之一是缓存预加载。

  1. @Cacheable(value = "people", key = "#person.id", depict = "用户信息缓存", 
  2.         firstCache = @FirstCache(expireTime = 10, timeUnit = TimeUnit.MINUTES), 
  3.         secondaryCache = @SecondaryCache(expireTime = 10, preloadTime = 2,timeUnit = TimeUnit.HOURS,)) 
  4. public Person findOne(Person person) { 
  5.     Person p = personRepository.findOne(Example.of(person)); 
  6.     logger.info("为id、key为:" + p.getId() + "数据做了缓存"); 
  7.     return p; 
  8. } 

在 layering-cache里面二级缓存会配置两个时间，expireTime是缓存的过期时间，preloadTime 是缓存的刷新时间(预加载时间)。每次二级缓存被命中都会去检查缓存的过去时间是否小于刷新时间，如果小于就会开启一个异步线程预先去更新缓存，并将新的值放到缓存中，有效的保证了热点数据**"永不过期"**。这里预先更新缓存也是需要加锁的，并不是所有的线程都会落到库上刷新缓存，如果没有获取到锁就直接结束当前线程。

  1. /** 
  2.  * 刷新缓存数据 
  3.  */ 
  4. private  void refreshCache(RedisCacheKey redisCacheKey, Callable valueLoader, Object result) { 
  5.     Long ttl = redisTemplate.getExpire(redisCacheKey.getKey()); 
  6.     Long preload = preloadTime; 
  7.     // 允许缓存NULL值，则自动刷新时间也要除以倍数 
  8.     boolean flag = isAllowNullValues() && (result instanceof NullValue || result == null); 
  9.     if (flag) { 
  10.         preload = preload / getMagnification(); 
  11.     } 
  12.     if (null != ttl && ttl > 0 && TimeUnit.SECONDS.toMillis(ttl) <= preload) { 
  13.         // 判断是否需要强制刷新在开启刷新线程 
  14.         if (!getForceRefresh()) { 
  15.             logger.debug("redis缓存 key={} 软刷新缓存模式", redisCacheKey.getKey()); 
  16.             softRefresh(redisCacheKey); 
  17.         } else { 
  18.             logger.debug("redis缓存 key={} 强刷新缓存模式", redisCacheKey.getKey()); 
  19.             forceRefresh(redisCacheKey, valueLoader); 
  20.         } 
  21.     } 
    1. /** 
    2.  * 硬刷新（执行被缓存的方法） 
    3.  * 
    4.  * @param redisCacheKey {@link RedisCacheKey} 
    5.  * @param valueLoader   数据加载器 
    6.  */ 
    7. private  void forceRefresh(RedisCacheKey redisCacheKey, Callable valueLoader) { 
    8.     // 尽量少的去开启线程，因为线程池是有限的 
    9.     ThreadTaskUtils.run(() -> { 
    10.         // 加一个分布式锁，只放一个请求去刷新缓存 
    11.         Lock redisLock = new Lock(redisTemplate, redisCacheKey.getKey() + "_lock"); 
    12.         try { 
    13.             if (redisLock.lock()) { 
    14.                 // 获取锁之后再判断一下过期时间，看是否需要加载数据 
    15.                 Long ttl = redisTemplate.getExpire(redisCacheKey.getKey()); 
    16.                 if (null != ttl && ttl > 0 && TimeUnit.SECONDS.toMillis(ttl) <= preloadTime) { 
    17.                     // 加载数据并放到缓存 
    18.                     loaderAndPutValue(redisCacheKey, valueLoader, false); 
    19.                 } 
    20.             } 
    21.         } catch (Exception e) { 
    22.             logger.error(e.getMessage(), e); 
    23.         } finally { 
    24.             redisLock.unlock(); 
    25.         } 
    26.     }); 
    27. } 
    在缓存总量和并发量都很大的时候，这个时候缓存如果同时失效，缓存预热将是一个非常慢长的过程，就比如说服务重启或新上线一个新的缓存。这个时候我们可以采用切流的方式，让缓存慢慢预热，如开始切10%流量，观察没有异常后，再切30%流量，观察没有异常后，再切60%流量，然后全量。这种方式虽然有点繁琐，但是一旦遇到异常我们可以快速的切回流量，让风险可控。
                
    
                网页名称：为什么大多数IP地址通常以192.168开头？
                
    
                文章地址：https://www.cdcxhl.com/news/104486.html
            
    
            
    
                                    成都网站建设公司_创新互联，为您提供营销型网站建设、网站排名、小程序开发、网站策划、网页设计公司、网站设计公司            
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联
            
    
        
    
        
    
            
    猜你还喜欢下面的内容
    
            
        
    
    
    

    
    
        外贸网站建设
        
    
            
    网站建设知识
    
            
        
    
        
    
            
    行业建站