案例解决Redis高并发场景带来的缓存穿透、击穿、雪崩问题(超级详细!!)

假设你的网站流量量达到亿级,传统的去查询DB势必会给DB带来巨大的压力,甚至可能有宕机的风险,接下来我就分几个阶段,来讲诉各个场景可能会给DB带来巨大压力的可能,以及优化的方案。

  • 缓存击穿:key对应的数据存在,但在redis中过期,此时若有大量并发请求过来,这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存,这个时候大并发的请求可能会瞬间把后端DB压垮。
  • 缓存穿透:key对应的数据在数据源并不存在,每次针对此key的请求从缓存获取不到,请求都会到数据源,从而可能压垮数据源。比如用一个不存在的用户id获取用户信息,不论缓存还是数据库都没有,若黑客利用此漏洞进行攻击可能压垮数据库。
  • 缓存雪崩:当缓存服务器重启或者大量缓存集中在某一个时间段失效,这样在失效的时候,也会给后端系统(比如DB)带来很大压力。

场景导入

* 最初的数据Redis的数据查询方法
* 假设是查询product 产品的信息
* 场景:当商品的数据有几亿的时候,直接请求到数据库,会造成数据库的压力过大,而产生宕机风险


    private final static String PRODUCT_NAME_KEY = "product:name:key:";

    public PatrolTask one(Long productId) {
        PatrolTask patrolTask;
        String productCacheKey = PRODUCT_NAME_KEY + productId;
        //去缓存中找到对应的产品数据,并取出
        String productStr = redisUtil.get(productCacheKey);

        if (C.isNotEmpty(productStr)) {
            patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
            return patrolTask;
        }

        PatrolTask dbData = iPatrolTaskService.getById(productId);
        if (C.isNotEmpty(dbData)) {
            //如果去数据库查找到的商品是不空的情况下,把数据再次放入到缓存中
            redisUtil.set(productCacheKey, JSON.toJSON(dbData));
        }
        return dbData;
    }

以上代码可能会导致的问题:  

* 上面的会造成的问题,如果把几亿的数据量都放入的缓存中

* 但是常用的就那么几个商品,就会占用大量的内存资源,消耗内存

第二次改造

给放入的缓存加入一定的过期时间,这样不常用的数据到期就会自动删除

    public PatrolTask two(Long productId) {
        PatrolTask patrolTask;
        String productCacheKey = PRODUCT_NAME_KEY + productId;
        String productStr = redisUtil.get(productCacheKey);

        if (C.isNotEmpty(productStr)) {
            patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
            return patrolTask;
        }

        PatrolTask dbData = iPatrolTaskService.getById(productId);
        if (C.isNotEmpty(dbData)) {
            //放入缓存中时,加入过期时间,防止数量过大
            redisUtil.set(productCacheKey, JSON.toJSON(dbData), PRODUCT_TIME);
        }
        return dbData;
    }

以上代码可能会导致的问题:  

* 以上代码存在问题:如果说我批量导入10000个产品,在缓存中的商品会同一时间都过期

* 而这个时间又有大量的请求打入来查询商品 就会造成了缓存雪崩现象 

缓存雪崩

当缓存服务器重启或者大量缓存集中在某一个时间段失效,这样在失效的时候,也会给后端系统(比如DB)带来很大压力

第三次改造

 给过期时间设置随机值,不让他们同一时间失效,或者是热点缓存永不过期

    public PatrolTask third(Long productId) {
        PatrolTask patrolTask;
        String productCacheKey = PRODUCT_NAME_KEY + productId;
        String productStr = redisUtil.get(productCacheKey);

        if (C.isNotEmpty(productStr)) {
            patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
            return patrolTask;
        }

        PatrolTask dbData = iPatrolTaskService.getById(productId);
        if (C.isNotEmpty(dbData)) {
            //设置缓存时间的随机
            redisUtil.set(productCacheKey, JSON.toJSON(dbData), getProductCacheTime());
        }
        return dbData;
    }


    //设置缓存时间的随机值
    private Long getProductCacheTime() {
        return PRODUCT_TIME + new Random().nextInt(30) * 60;

    }

 以上代码可能会导致的问题:  

* 以上代码存在问题:如果运营人员现在把热点的商品进行了删除,但是这个时间又有大量的人来访问这个商品。
* 而在缓存中都查不到,就回去查数据库,就会给数据库造成巨大压力,这种现象就叫做缓存穿透

缓存穿透

key对应的数据在数据源并不存在,每次针对此key的请求从缓存获取不到,请求都会到数据源,从而可能压垮数据源。比如用一个不存在的用户id获取用户信息,不论缓存还是数据库都没有,若黑客利用此漏洞进行攻击可能压垮数据库

第四次改造

解决的办法,就是如果说数据库查不到,我们就返回一个空对象,存入缓存中,防止大量数据库直接打入数据库

    public PatrolTask four(Long productId) {
        PatrolTask patrolTask;
        String productCacheKey = PRODUCT_NAME_KEY + productId;
        String productStr = redisUtil.get(productCacheKey);

        if (C.isNotEmpty(productStr)) {
            //如果查到的值为空,就直接进行返回一个空的对象
            if (PRODUCT_EMPTY.equals(productStr)) {
                return new PatrolTask();
            }
            patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
            return patrolTask;
        }

        PatrolTask dbData = iPatrolTaskService.getById(productId);
        if (C.isNotEmpty(dbData)) {

            redisUtil.set(productCacheKey, JSON.toJSON(dbData), getProductCacheTime());
        } else {
            //缓存一个空的值
            redisUtil.set(productCacheKey, PRODUCT_EMPTY, getProductCacheTime());

        }

        return dbData;
    }

 以上代码可能会存在的问题:  

* 以上代码存在问题:如果说之前在缓存中没有这个数据,那么之前数据就有可能没有在缓存中
* 但是突然这个数据并发了大量的并发,就有可能大量的同一时间去创建这个缓存数据,就会给系统造成压力暴增问题,就会出现缓存击穿现象

缓存击穿

key对应的数据存在,但在redis中过期,此时若有大量并发请求过来,这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存,这个时候大并发的请求可能会瞬间把后端DB压垮

 第五次改造

我在查询缓存的时间,加一把锁synchronized (this) ,这样只会有一个线程进来查询,利用 单利模式的双重检测锁的实现来优化,并放入缓存中,不会有大量的数据进来

    public PatrolTask five(Long productId) {
        PatrolTask patrolTask;
        String productCacheKey = PRODUCT_NAME_KEY + productId;
        String productStr = redisUtil.get(productCacheKey);

        if (C.isNotEmpty(productStr)) {
            //如果查到的值为空,就直接进行返回一个空的对象
            if (PRODUCT_EMPTY.equals(productStr)) {
                return new PatrolTask();
            }
            patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
            return patrolTask;
        }

        //加锁,只保证有一个线程能够进来
        synchronized (this)  {
             // 这里再去查一次缓存,相当于第二个请求,就会查缓存,用到了单利设计模式
            if (C.isNotEmpty(productStr)) {
                if (PRODUCT_EMPTY.equals(productStr)) {
                    return new PatrolTask();
                }
                patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
                return patrolTask;
            }

            PatrolTask dbData = iPatrolTaskService.getById(productId);
            if (C.isNotEmpty(dbData)) {

                redisUtil.set(productCacheKey, JSON.toJSON(dbData), getProductCacheTime());
            } else {
               
                redisUtil.set(productCacheKey, PRODUCT_EMPTY, getProductCacheTime());

            }
            return dbData;

        }


    }

以上代码可能会存在的问题:    

synchronized锁事非常重的锁,分布式环境情况下,每个系统都会去重建一次,会造成一定的性能开销,目前这个的性能开销并不大,但是(this)锁的范围非常大!!

会把所有的商品的查询都给锁住,会造成巨大的性能开销。

所以上锁的时候,一定要去考虑锁的范围,范围越小越好

  第五次改造

采用分布式锁Redisson来解决以上的问题,锁的对象能加锁的到产品的对象,这样范围就会很小。

    @Autowired
    private Redisson redisson;

    private final static String product_lock = "product:lock";


    public PatrolTask six(Long productId) {
        PatrolTask patrolTask;
        String productCacheKey = PRODUCT_NAME_KEY + productId;
        String productStr = redisUtil.get(productCacheKey);

        if (C.isNotEmpty(productStr)) {
            //如果查到的值为空,就直接进行返回一个空的对象
            if (PRODUCT_EMPTY.equals(productStr)) {
                return new PatrolTask();
            }
            patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
            return patrolTask;
        }

        RLock lock = redisson.getLock(product_lock + productId);
        //加锁
        lock.lock(20, TimeUnit.MINUTES);
        try {

            if (C.isNotEmpty(productStr)) {
                if (PRODUCT_EMPTY.equals(productStr)) {
                    return new PatrolTask();
                }
                patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
                return patrolTask;
            }

            patrolTask = iPatrolTaskService.getById(productId);
            if (C.isNotEmpty(patrolTask)) {

                redisUtil.set(productCacheKey, JSON.toJSON(patrolTask), getProductCacheTime());
            } else {

                redisUtil.set(productCacheKey, PRODUCT_EMPTY, getProductCacheTime());
            }

        } finally {
            //释放锁
            lock.unlock();

        }

        return patrolTask;

    }

以上代码可能会存在的问题:    

如果在我们查到数据的时间,整个网络有延时的情况,就在这个时候,有人更新人这个产品,并已存入数据库,而我们拿到的是旧的信息,并放入了缓存中,那么下次来查询的时候,查询缓存发现有数据,就会直接返回,只有 等缓存过期了才会更新缓存。这就是典型的缓存与数据库不一致问题

案例解决Redis高并发场景带来的缓存穿透、击穿、雪崩问题(超级详细!!)_第1张图片   第五次改造

常用的方案:延迟双删、加(Redisson读写锁)以下提供Redisson的读写锁的操作,下面我讲解的是读锁的代码,写的代码,同理在update更新操作的时候,你锁同一个对象,并readWriteLock.writeLock() 获取到读的锁就可以,读写锁不清楚的可自行了解下

    @Autowired
    private Redisson redisson;

    private final static String product_lock = "product:lock";


    public PatrolTask six(Long productId) {
        PatrolTask patrolTask;
        String productCacheKey = PRODUCT_NAME_KEY + productId;
        String productStr = redisUtil.get(productCacheKey);

        if (C.isNotEmpty(productStr)) {
            //如果查到的值为空,就直接进行返回一个空的对象
            if (PRODUCT_EMPTY.equals(productStr)) {
                return new PatrolTask();
            }
            patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
            return patrolTask;
        }

        RLock lock = redisson.getLock(product_lock + productId);
        //加锁
        lock.lock(20, TimeUnit.MINUTES);
        try {

            if (C.isNotEmpty(productStr)) {
                if (PRODUCT_EMPTY.equals(productStr)) {
                    return new PatrolTask();
                }
                patrolTask = JSONObject.parseObject(productStr, PatrolTask.class);
                return patrolTask;
            }

            RReadWriteLock readWriteLock = redisson.getReadWriteLock(product_lock + productId);
            RLock rLock = readWriteLock.readLock();
            try {
                patrolTask = iPatrolTaskService.getById(productId);
                if (C.isNotEmpty(patrolTask)) {

                    redisUtil.set(productCacheKey, JSON.toJSON(patrolTask), getProductCacheTime());
                } else {

                    redisUtil.set(productCacheKey, PRODUCT_EMPTY, getProductCacheTime());
                }
                
            }   finally {
                rLock.unlock();
            }
         
        } finally {
            //释放锁
            lock.unlock();

        }
        return patrolTask;

    }

你可能感兴趣的:(缓存,redis,数据库)