Redis缓存穿透、击穿、雪崩

Redis缓存穿透、击穿、雪崩

Redis缓存的使用,极大程度带来了应用的性能和效率,特别是数据查询方面。
为了保证数据的时效性,会设置缓存过期时间,在缓存过期那一瞬间,有大量的缓存请求,会导致请求穿透到持久层,这时持久层的压力就非常大,可能导致缓存问题。

  1. 缓存雪崩: (大量的数据或者全部的数据集中过期)
    缓存雪崩是指在设置缓存时采用了相同的过期时间,导致缓存在某一时刻同时失效,导致所有的查询都落在数据库上,造成了缓存雪崩。
    解决方案:
    1)在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存,其他线程等待。
    2)可以通过缓存reload机制,预先去更新缓存,在即将发生大并发访问前手动触发加载缓存。
    3)不同的key,设置不同的过期时间,让缓存失效的时间点尽量均匀。
    4)做二级缓存,或者双缓存策略。A1为原始缓存,A2为拷贝缓存,A1失效时,可以访问A2,A1缓存失效时间设置为短期,A2设置为长期。
    5) Promise方案:
    promise方案,是将同一进程中对同一个缓存访问的汇总, 不仅可以减少对持久层的缓存穿透,而且可以降低对缓存层的请求量,拥有极强的汇聚效果。
    特点:在一段时间内,集中过期,不是最致命的,最致命的是缓存服务器某个节点宕机或断网

  2. 缓存穿透:是指查询一个数据库一定不存在的数据。
    查不到数据,则不写入缓存,这导致这个不存在的数据每次请求都要到数据库去查询,造成缓存穿透。
    解决方案:
    1)采用布隆过滤器,将所有可能存在的数据哈希到一个足够大的bitmap中,一个一定不存在的数据会被这个bitmap拦截掉,从而避免了对底层数据库的查询压力。
    2)一个更为简单粗暴的方法,如果一个查询返回的数据为空(不管是数据不存在,还是系统故障),仍然把这个空结果进行缓存,但它的过期时间会很短,最长不超过五分钟。
    在这里插入图片描述

  3. 缓存击穿: (热点数据过期)
    是指一个key非常热点,在不停的扛着大并发。类似与在一面墙上凿了一个洞,穿过这个洞到达后面的数据库。
    在这里插入图片描述
    解决方案:
    1)后台刷新
    后台定义一个job(定时任务)专门主动更新缓存数据.比如,一个缓存中的数据过期时间是30分钟,那么job每隔29分钟定时刷新数据(将从数据库中查到的数据更新到缓存中).
    注:这种方案比较容易理解,但会增加系统复杂度。比较适合那些 key 相对固定,cache 粒度较大的业务,key 比较分散的则不太适合,实现起来也比较复杂。
    2)检查更新
    将缓存key的过期时间(绝对时间)一起保存到缓存中(可以拼接,可以添加新字段,可以采用单独的key保存…不管用什么方式,只要两者建立好关联关系就行).在每次执行get操作后,都将get出来的缓存过期时间与当前系统时间做一个对比,如果缓存过期时间-当前系统时间<=1分钟(自定义的一个值),则主动更新缓存.这样就能保证缓存中的数据始终是最新的(和方案一一样,让数据不过期.)
    注:这种方案在特殊情况下也会有问题。假设缓存过期时间是12:00,而 11:59 到 12:00这 1 分钟时间里恰好没有 get 请求过来,又恰好请求都在 11:30 分的时 候高并发过来,那就悲剧了。这种情况比较极端,但并不是没有可能。因为“高 并发”也可能是阶段性在某个时间点爆发。
    3)分级缓存
    采用 L1 (一级缓存)和 L2(二级缓存) 缓存方式,L1 缓存失效时间短,L2 缓存失效时间长。 请求优先从 L1 缓存获取数据,如果 L1缓存未命中则加锁,只有 1 个线程获取到锁,这个线程再从数据库中读取数据并将数据再更新到到 L1 缓存和 L2 缓存中,而其他线程依旧从 L2 缓存获取数据并返回。
    注:这种方式,主要是通过避免缓存同时失效并结合锁机制实现。所以,当数据更 新时,只能淘汰 L1 缓存,不能同时将 L1 和 L2 中的缓存同时淘汰。L2 缓存中 可能会存在脏数据,需要业务能够容忍这种短时间的不一致。而且,这种方案 可能会造成额外的缓存空间浪费。
    4)加锁

// 方法1:
   public synchronized List<String> getData01() {
       List<String> result = new ArrayList<String>();
       // 从缓存读取数据
       result = getDataFromCache();
       if (result.isEmpty()) {
           // 从数据库查询数据
           result = getDataFromDB();
           // 将查询到的数据写入缓存
           setDataToCache(result);
       }
       return result;
   } 
注:这种方式确实能够防止缓存失效时高并发到数据库,但是缓存没有失效的时候,在从缓存中拿数据时需要排队取锁,这必然会大大的降低了系统的吞吐量.

// 方法2:
   static Object lock = new Object();
   public List<String> getData02() {
       List<String> result = new ArrayList<String>();
       // 从缓存读取数据
       result = getDataFromCache();
       if (result.isEmpty()) {
           synchronized (lock) {
               // 从数据库查询数据
               result = getDataFromDB();
               // 将查询到的数据写入缓存
               setDataToCache(result);
           }
       }
       return result;
   } 
注:这个方法在缓存命中的时候,系统的吞吐量不会受影响,但是当缓存失效时,请求还是会打到数据库,只不过不是高并发而是阻塞而已.但是,这样会造成用户体验不佳,并且还给数据库带来额外压力.

//方法3
   public List<String> getData03() {
       List<String> result = new ArrayList<String>();
       // 从缓存读取数据
       result = getDataFromCache();
       if (result.isEmpty()) {
           synchronized (lock) {
           //双重判断,第二个以及之后的请求不必去找数据库,直接命中缓存
               // 查询缓存
               result = getDataFromCache();
               if (result.isEmpty()) {
                   // 从数据库查询数据
                   result = getDataFromDB();
                   // 将查询到的数据写入缓存
                   setDataToCache(result);
               }
           }
       }
       return result;
   }
注:双重判断虽然能够阻止高并发请求打到数据库,但是第二个以及之后的请求在命中缓存时,还是排队进行的.比如,当30个请求一起并发过来,在双重判断时,第一个请求去数据库查询并更新缓存数据,剩下的29个请求则是依次排队取缓存中取数据.请求排在后面的用户的体验会不爽.

//方法4:
static Lock reenLock = new ReentrantLock();
   public List<String> getData04() throws InterruptedException {
       List<String> result = new ArrayList<String>();
       // 从缓存读取数据
       result = getDataFromCache();
       if (result.isEmpty()) {
           if (reenLock.tryLock()) {
               try {
                   System.out.println("我拿到锁了,从DB获取数据库后写入缓存");
                   // 从数据库查询数据
                   result = getDataFromDB();
                   // 将查询到的数据写入缓存
                   setDataToCache(result);
               } finally {
                   reenLock.unlock();// 释放锁
               }
           } else {
               result = getDataFromCache();// 先查一下缓存
               if (result.isEmpty()) {
                   System.out.println("我没拿到锁,缓存也没数据,先小憩一下");
                   Thread.sleep(100);// 小憩一会儿
                   return getData04();// 重试
               }
           }
       }
       return result;
   }
注:最后使用互斥锁的方式来实现,可以有效避免前面几种问题。
  1. 面试题:如何在海量元素中(例如10亿无序,不定长,不重复)快速判断
    一个元素是否存在?
    使用 位图(BitMap)

  2. 布隆过滤器
    5.1 本质:位数组(二进制向量);一系列随机映射函数
    注:布隆过滤器一定存在误判率
    5.2 经过布隆过滤器算出来都是1,有可能在集合存在,也有可能不存在
    但是有一个是0,那么肯定是不存在集合中
    如果一个元素存在,那么过滤器一定存在
    如果一个元素实际不存在,布隆过滤器有可能判断存在
    在这里插入图片描述
    5.3 怎么减少哈希碰撞?
    扩大位图容量 ;增加hash function
    5.4 布隆过滤器应用:
    爬虫 url, 垃圾邮箱 Spamer
    5.5 布隆过滤器删除key,利用counting ,某个key通过布隆过滤器计算出某个位置,就将该位置置为1,并且counting+1,删除key类似,计算出某个位置,先counting-1,然后判断是否counting为0,为0,则将该位置置为0。这样会导致集合内存结构更加复杂,使用内存增大,还需要额外维护counting。

思维导图:
在这里插入图片描述

  • 2
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值