应对缓存击穿的解决方法

一.什么样的数据适合缓存?

分析一个数据是否适合缓存,我们要从访问频率、读写比例、数据一致性等要求去分析.
这里写图片描述

二.什么是缓存击穿

在高并发下,多线程同时查询同一个资源,如果缓存中没有这个资源,那么这些线程都会去数据库查找,对数据库造成极大压力,缓存失去存在的意义.打个比方,数据库是人,缓存是防弹衣,子弹是线程,本来防弹衣是防止子弹打到人身上的,但是当防弹衣里面没有防弹的物质时,子弹就会穿过它打到人身上.
这里写图片描述

三.缓存击穿的解决办法

方案一

后台刷新

后台定义一个job(定时任务)专门主动更新缓存数据.比如,一个缓存中的数据过期时间是30分钟,那么job每隔29分钟定时刷新数据(将从数据库中查到的数据更新到缓存中).

  • 这种方案比较容易理解,但会增加系统复杂度。比较适合那些 key 相对固定,cache 粒度较大的业务,key 比较分散的则不太适合,实现起来也比较复杂。
方案二

检查更新

将缓存key的过期时间(绝对时间)一起保存到缓存中(可以拼接,可以添加新字段,可以采用单独的key保存..不管用什么方式,只要两者建立好关联关系就行).在每次执行get操作后,都将get出来的缓存过期时间与当前系统时间做一个对比,如果缓存过期时间-当前系统时间<=1分钟(自定义的一个值),则主动更新缓存.这样就能保证缓存中的数据始终是最新的(和方案一一样,让数据不过期.)

  • 这种方案在特殊情况下也会有问题。假设缓存过期时间是12:00,而 11:59
    到 12:00这 1 分钟时间里恰好没有 get 请求过来,又恰好请求都在 11:30 分的时
    候高并发过来,那就悲剧了。这种情况比较极端,但并不是没有可能。因为“高
    并发”也可能是阶段性在某个时间点爆发。
方案三

分级缓存

采用 L1 (一级缓存)和 L2(二级缓存) 缓存方式,L1 缓存失效时间短,L2 缓存失效时间长。 请求优先从 L1 缓存获取数据,如果 L1缓存未命中则加锁,只有 1 个线程获取到锁,这个线程再从数据库中读取数据并将数据再更新到到 L1 缓存和 L2 缓存中,而其他线程依旧从 L2 缓存获取数据并返回。

  • 这种方式,主要是通过避免缓存同时失效并结合锁机制实现。所以,当数据更
    新时,只能淘汰 L1 缓存,不能同时将 L1 和 L2 中的缓存同时淘汰。L2 缓存中
    可能会存在脏数据,需要业务能够容忍这种短时间的不一致。而且,这种方案
    可能会造成额外的缓存空间浪费。
方案四

加锁

方法1
    // 方法1:
    public synchronized List<String> getData01() {
        List<String> result = new ArrayList<String>();
        // 从缓存读取数据
        result = getDataFromCache();
        if (result.isEmpty()) {
            // 从数据库查询数据
            result = getDataFromDB();
            // 将查询到的数据写入缓存
            setDataToCache(result);
        }
        return result;
    }
  • 这种方式确实能够防止缓存失效时高并发到数据库,但是缓存没有失效的时候,在从缓存中拿数据时需要排队取锁,这必然会大大的降低了系统的吞吐量.
方法2
// 方法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
//方法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;
    }
  • 最后使用互斥锁的方式来实现,可以有效避免前面几种问题.

当然,在实际分布式场景中,我们还可以使用 redis、tair、zookeeper 等提供的分布式锁来实现.但是,如果我们的并发量如果只有几千的话,何必杀鸡焉用牛刀呢?

  • 13
    点赞
  • 37
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
缓存击穿、穿透和雪崩都是与缓存相关的问题,以下是它们的简要解释: 1. 缓存击穿(Cache Miss): 缓存击穿是指在高并发情况下,一个请求查询一个不存在于缓存中的数据,导致该请求穿透缓存,直接访问数据库。这会导致大量请求同时访问数据库,增加数据库的负载,并降低系统性能。 解决方案: 针对缓存击穿问题,可以使用互斥锁或分布式锁来保证只有一个线程能够访问数据库并更新缓存。另外,可以考虑设置短暂的缓存过期时间,以减少对数据库的频繁请求。 2. 缓存穿透(Cache Penetration): 缓存穿透是指恶意请求或不存在于数据库中的数据不断访问缓存,导致每次请求都直接访问数据库,从而绕过缓存层。这也会导致数据库负载过高,影响系统性能。 解决方案: 为了避免缓存穿透,可以采取一些策略,如对查询结果为空的请求也进行缓存,但将其设置为一个特定的值,例如null。此外,可以通过使用布隆过滤器等技术来过滤无效请求,减轻数据库的负载。 3. 缓存雪崩(Cache Avalanche): 缓存雪崩是指在缓存中大量的数据同时过期或失效,导致大量请求直接访问数据库,造成数据库负载激增,甚至导致系统崩溃。通常是由于缓存服务器故障、程序bug、缓存设置不当等原因引起。 解决方案: 为了应对缓存雪崩,可以采取一些措施。例如,通过设置不同的缓存过期时间,使缓存的失效时间错开,避免同时失效。另外,可以考虑使用多级缓存架构,将请求分散到不同的缓存服务器上,减少单点故障的风险。 总结: 为了避免缓存击穿、穿透和雪崩问题,需要合理设置缓存策略、使用合适的缓存技术,并且进行监控和预警,及时发现和解决潜在问题。此外,合理的系统设计和架构也是减少这些问题发生的重要手段。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值