Redis的缓存问题之缓存穿透缓存雪崩缓存击穿

Posted 爱上口袋的天空

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Redis的缓存问题之缓存穿透缓存雪崩缓存击穿相关的知识,希望对你有一定的参考价值。

目录

一、什么是缓存穿透?

二、常见的解决方案有两种:

1、缓存空对象

2、布隆过滤

综上所述

三、编码解决商品查询的缓存穿透问题

四、缓存雪崩问题及解决思路

1、什么是缓存雪崩?

五、缓存击穿问题及解决思路

 1、什么是缓存击穿?

2、解决方案(2种)

(1)互斥锁

 (2)逻辑过期

3、互斥锁与逻辑过期的对比分析

六、利用互斥锁解决缓存击穿问题

代码实现

七、利用逻辑过期解决缓存击穿问题

需求描述

代码实现

八、封装 Redis 工具类


一、什么是缓存穿透?

        缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在,这样缓存永远不会生效,这些请求都会打到数据库


二、常见的解决方案有两种:

1、缓存空对象

 

简单的来说,就是请求之后,发现数据不存在,就将null值打入Redis中

  • 优点:实现简单,维护方便
  • 缺点:
    • 额外的内存消耗
    • 可能造成短期的不一致

思路分析:

        当我们客户端访问不存在的数据时,先请求 redis,但是此时 redis 中没有数据,此时会访问到数据库,但是数据库中也没有数据,这个数据穿透了缓存,直击数据库,我们都知道数据库能够承载的并发不如 redis 这么高,如果大量的请求同时过来访问这种不存在的数据,这些请求就都会访问到数据库,简单的解决方案就是哪怕这个数据在数据库中也不存在,我们也把这个数据存入到 redis 中去,这样,下次用户过来访问这个不存在的数据,那么在 redis 中也能找到这个数据就不会进入到数据库了。

2、布隆过滤

在客户端与Redis之间加了一个布隆过滤器,对于请求进行过滤。 

        布隆过滤器的大致的原理:布隆过滤器中存放二进制位。数据库的数据通过hash算法计算其hash值并存放到布隆过滤器中,之后判断数据是否存在的时候,就是判断该hash值是0还是1

        但是这个玩意是一种概率上的统计,当其判断不存在的时候就一定是不存在;当其判断存在的时候就不一定存在。所以有一定的穿透风险!!!

  • 优点:内存占用较少,没有多余 key
  • 缺点:
    • 实现复杂
    • 存在误判可能

综上所述

我们可以两种方案一起用,这样子最为保险。据统计使用布隆过滤器一般可以避免90%的无效请求。但是黑马程序员这里的视频是使用方案一(缓存空对象)。


三、编码解决商品查询的缓存穿透问题

核心思路如下:

在原来的逻辑中,我们如果发现这个数据在 mysql 中不存在,直接就返回 404 了,这样是会存在缓存穿透问题的

        现在的逻辑中:如果这个数据不存在,我们不会返回 404 ,还是会把这个数据写入到 Redis 中,并且将 value 设置为空,欧当再次发起查询时,我们如果发现命中之后,判断这个 value 是否是 null,如果是 null,则是之前写入的数据,证明是缓存穿透数据,如果不是,则直接返回数据。

 

显然我们在这里只要做两件事:

  • 当查询数据在数据库中不存在时,将空值写入 redis
  •  判断缓存是否命中后,再加一个判断是否为空值
@Override
public Result queryById(Long id) 
 
    // 从redis查询商铺缓存
    String key = CACHE_SHOP_KEY + id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
 
    // 判断是否存在
    if (StrUtil.isNotBlank(shopJson)) 
        // 存在,直接返回
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    
 
    // 1.判断空值
    if (shopJson != null) 
        // 返回一个错误信息
        return Result.fail("店铺不存在!");
    
 
 
    // 不存在,根据id查询数据库
    Shop shop = getById(id);
 
    // 不存在,返回错误
    if (shop == null) 
        
        // 2.防止穿透问题,将空值写入redis!!!
        stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
        return Result.fail("店铺不存在!");
    
 
    // 存在,写入Redis
    // 把shop转换成为JSON形式写入Redis
    // 同时添加超时时间
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
    return Result.ok(shop);

 小总结:

缓存穿透产生的原因是什么?

  • 用户请求的数据在缓存中和数据库中都不存在,不断发起这样的请求,给数据库带来巨大压力

缓存穿透的解决方案有哪些?

  • 缓存 null 值
  • 布隆过滤
  • 增强 id 的复杂度,避免被猜测 id 规律
  • 做好数据的基础格式校验
  • 加强用户权限校验
  • 做好热点参数的限流

四、缓存雪崩问题及解决思路

1、什么是缓存雪崩?

        缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机,导致大量请求到达数据库,带来巨大压力。情况大致如下图所示:

解决方案(4种)

  • (1)给不同的Key的TTL添加随机值(推荐)

        操作简单,当我们在做缓存预热的时候,就有可能在同一时间批量插入大量的数据,那么如果它们的TTL都一样的话就可能出现大量key同时过期的情况!!!所以我们需要在设置过期时间TTL的时候,定义一个范围,追加该范围内的一个随机数。

  • (2)利用Redis集群提高服务的可用性

        使用集群提高可靠性,后续讲解~~~之后写了会在这里贴上链接。

  • (3)给缓存业务添加降级限流策略

        也是后续的微服务的知识~~~SpringCloud中有提!!!

  • (4)给业务添加多级缓存  

        请求到达浏览器,nginx可以做缓存,未命中找Redis,再未命中找JVM,最后到数据库......


五、缓存击穿问题及解决思路

 1、什么是缓存击穿?

缓存雪崩是因为大量的key同时过期所导致的问题,而缓存击穿则是部分key过期导致的严重后果

为什么大量key过期会产生问题而少量的key也会有问题呢???

这是因为这一部分的key不简单!!!

缓存击穿问题也叫热点Key问题,就是⼀个被高并发访问并且缓存重建业务较复杂的key突然失效了,无数的请求访问会在瞬间给数据库带来巨大的冲击

具体情况如下图所示:

上述:此时假设该热点key的TTL时间到(失效了),则查询缓存未命中,会继续查询数据库,并进行缓存重建工作但是由于查询SQL逻辑比较复杂、重建缓存的时间较久,并且该key又是热点key,短时间内有大量的线程对其进行访问,所以请求会直接 “打到” 数据库中,数据库就有可能崩掉!!!

2、解决方案(2种)

(1)互斥锁

  • 简单的来说就是,并不是所有的线程都有 “ 资格 ” 去访问数据库,只有持有的线程才可以对其进行操作。
  • 不过该操作有一个很明显的问题,就是会出现相互等待的情况。

 (2)逻辑过期

 不设置TTL,之前所说导致缓存击穿的原因就是该key的TTL到期了,所以我们在这就不设置TTL了,而是使用一个字段例如:expire表示过期时间(逻辑上的)。当我们想让它 “ 过期 ” 的时候,我们可以直接手动将其删除(热点key,即只是在一段时间内,其被访问的频次很高)。

这种方案巧妙在于,异步的构建缓存,缺点在于在构建完缓存之前,返回的都是脏数据

3、互斥锁与逻辑过期的对比分析

 


六、利用互斥锁解决缓存击穿问题

        核心思路:相较于原来从缓存中查询不到数据后直接查询数据库而言,现在的方案是 进行查询之后,如果从缓存没有查询到数据,则进行互斥锁的获取,获取互斥锁后,判断是否获得到了锁,如果没有获得到,则休眠,过一会再进行尝试,直到获取到锁为止,才能进行查询

        如果获取到了锁的线程,再去进行查询,查询后将数据写入 redis,再释放锁,返回数据,利用互斥锁就能保证只有一个线程去执行操作数据库的逻辑,防止缓存击穿。

 

代码实现

(1)首先,我们声明一下获取锁、释放锁的方法,tryLock()、unLock()

/**
  * 获取锁
  * @param key
  * @return
*/
private boolean tryLock(String key) 
    // setnx 就是 setIfAbsent 如果存在
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.MINUTES);
    // 装箱是将值类型装换成引用类型的过程;拆箱就是将引用类型转换成值类型的过程
    // 不要直接返回flag,可能为null
    return BooleanUtil.isTrue(flag);

 
/**
 * 释放锁
 * @param key
 */
private void unLock(String key) 
    stringRedisTemplate.delete(key);

注意:这里的锁不是真正的线程锁,而是redis里面的一个特殊的key。 

2)互斥锁解决缓存击穿 queryWithMutex()

/**
 * 互斥锁解决缓存击穿 queryWithMutex()
 * @param id
 * @return
 */
public Shop queryWithMutex(Long id) 
    // 1.从redis查询商铺缓存
    String key = CACHE_SHOP_KEY + id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
 
    // 2.判断是否存在
    if (StrUtil.isNotBlank(shopJson)) 
        return JSONUtil.toBean(shopJson, Shop.class);
    
 
    // 判断空值
    if (shopJson != null) 
        // 返回一个错误信息
        return null;
    
 
    String lockKey = "lock:shop:" + id;
    Shop shop = null;
    try 
        // 4.实现缓存重建
        // 4.1获取互斥锁
        boolean isLock = tryLock(lockKey);
 
        // 4.2判断是否成功
        if (!isLock) 
            // 4.3失败,则休眠并重试
            Thread.sleep(50);
            // 递归
            return queryWithMutex(id);
        
        // 4.4成功,根据id查询数据库
        shop = getById(id);
 
        // 模拟延迟
        Thread.sleep(200);
 
        // 5.不存在,返回错误
        if (shop == null) 
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            return null;
        
 
        // 6.存在,写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL,TimeUnit.MINUTES);
 
     catch (InterruptedException ex) 
        throw new RuntimeException(ex);
     finally 
        // 7.释放锁
        unLock(lockKey);
    
 
    // 8.返回
    return shop;

 


七、利用逻辑过期解决缓存击穿问题

需求描述

修改根据id查询商铺的业务,基于逻辑过期方式来解决缓存击穿问题

 注意:这里的key是否过期,不是由redis控制的,而是由我们自己去手动编写逻辑去控制的。 

代码实现

(1)添加逻辑过期时间的字段

由于我们之前的Shop中是没有逻辑过期的字段,那么我们要如何让它带有这个属性,又不修改之前的代码呢?

新建一个RedisData对象,里面的data指的是Shop对象,而expireTime是逻辑过期时间。

即:我们可以使用 JSONUtil.toBean 将Shop对象通过序列化、反序列化到RedisData类的data属性中。

@Data
public class RedisData 
    // LocalDateTime : 同时含有年月日时分秒的日期对象
    // 并且LocalDateTime是线程安全的!
    private LocalDateTime expireTime;
    private Object data;

(2)逻辑过期解决缓存击穿问题 queryWithLogicalExpire()

缓存重建

/**
 * 重建缓存,先缓存预热一下,否则queryWithLogicalExpire() 的expire为null
 * @param id
 * @param expireSeconds
 */
public void saveShopRedis(Long id, Long expireSeconds) 
    // 1.查询店铺数据
    Shop shop = getById(id);
    // 2.封装逻辑过期时间
    RedisData redisData = new RedisData();
    redisData.setData(shop);
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));  // 过期时间
    // 3.写入redis
    stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));

先使用测试方法运行一下saveShopRedis(),否则redis里面没有expireTime !

private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

/**
 * 逻辑过期解决缓存击穿问题 queryWithLogicalExpire()
 * 测试前要先缓存预热一下!不然 data 与 expireTime 的缓存值是null!
 * @param id
 * @return
 */
public Shop queryWithLogicalExpire(Long id) 
    // 1.从redis查询商铺缓存
    String key = CACHE_SHOP_KEY + id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
 
    // 2.判断是否存在
    if (StrUtil.isBlank(shopJson)) 
        return null;
    
 
    // 4.命中,需要将json反序列化为对象
    // redisData没有数据
    RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
    Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();
 
    // 5.判断是否过期
    if (expireTime.isAfter(LocalDateTime.now())) 
        // 5.1未过期,直接返回店铺信息
        return shop;
    
 
    // 5.2已过期,需要缓存重建
    // 6.缓存重建
    // 6.1.获取互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    boolean islock = tryLock(lockKey);
    // 6.2.判断是否获取互斥锁成功
    if (islock) 
        // 6.3.成功,开启独立线程,实现缓存重建
        CACHE_REBUILD_EXECUTOR.submit( () -> 
            try 
                // 重建缓存,过期时间为20L
                saveShopRedis(id,20L);
             catch (Exception ex) 
                throw new RuntimeException(ex);
             finally 
                unLock(lockKey);
            
        );
    
    // 6.4.返回过期店铺信息
    return shop;

我们可以看到在测试的时候,name的值为:“100XXXX”

我们现在来修改一下数据库,将值改为:“900XXXX”,看看并发情况下缓存重建能否正确

通过Jmeter做压力测试

 再查看Redis中的数据,可以看到name的值已经被修改了,而且上面的jmeter的每一个http都是正常的!

 


八、封装 Redis 工具类

 

基于 StringRedisTemplate 封装一个缓存工具类,满足下列需求:

  • 方法 1:将任意 Java 对象序列化为 json 并存储在 string 类型的 key 中,并且可以设置 TTL 过期时间
  • 方法 2:将任意 Java 对象序列化为 json 并存储在 string 类型的 key 中,并且可以设置逻辑过期时间,用于处理缓

存击穿问题

  • 方法 3:根据指定的 key 查询缓存,并反序列化为指定类型,利用缓存空值的方式解决缓存穿透问题
  • 方法 4:根据指定的 key 查询缓存,并反序列化为指定类型,需要利用逻辑过期解决缓存击穿问题

将逻辑进行封装

@Slf4j
@Component
public class CacheClient 

    private final StringRedisTemplate stringRedisTemplate;

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    public CacheClient(StringRedisTemplate stringRedisTemplate) 
        this.stringRedisTemplate = stringRedisTemplate;
    

    public void set(String key, Object value, Long time, TimeUnit unit) 
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    

    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) 
        // 设置逻辑过期
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        // 写入Redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    

    public <R,ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit)
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(json)) 
            // 3.存在,直接返回
            return JSONUtil.toBean(json, type);
        
        // 判断命中的是否是空值
        if (json != null) 
            // 返回一个错误信息
            return null;
        

        // 4.不存在,根据id查询数据库
        R r = dbFallback.apply(id);
        // 5.不存在,返回错误
        if (r == null) 
            // 将空值写入redis
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            // 返回错误信息
            return null;
        
        // 6.存在,写入redis
        this.set(key, r, time, unit);
        return r;
    

    public <R, ID> R queryWithLogicalExpire(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) 
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isBlank(json)) 
            // 3.存在,直接返回
            return null;
        
        // 4.命中,需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
        LocalDateTime expireTime = redisData.getExpireTime();
        // 5.判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())) 
            // 5.1.未过期,直接返回店铺信息
            return r;
        
        // 5.2.已过期,需要缓存重建
        // 6.缓存重建
        // 6.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        // 6.2.判断是否获取锁成功
        if (isLock)
            // 6.3.成功,开启独立线程,实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> 
                try 
                    // 查询数据库
                    R newR = dbFallback.apply(id);
                    // 重建缓存
                    this.setWithLogicalExpire(key, newR, time, unit);
                 catch (Exception e) 
                    throw new RuntimeException(e);
                finally 
                    // 释放锁
                    unlock(lockKey);
                
            );
        
        // 6.4.返回过期的商铺信息
        return r;
    

    public <R, ID> R queryWithMutex(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) 
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) 
            // 3.存在,直接返回
            return JSONUtil.toBean(shopJson, type);
        
        // 判断命中的是否是空值
        if (shopJson != null) 
            // 返回一个错误信息
            return null;
        

        // 4.实现缓存重建
        // 4.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        R r = null;
        try 
            boolean isLock = tryLock(lockKey);
            // 4.2.判断是否获取成功
            if (!isLock) 
                // 4.3.获取锁失败,休眠并重试
                Thread.sleep(50);
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
            
            // 4.4.获取锁成功,根据id查询数据库
            r = dbFallback.apply(id);
            // 5.不存在,返回错误
            if (r == null) 
                // 将空值写入redis
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                // 返回错误信息
                return null;
            
            // 6.存在,写入redis
            this.set(key, r, time, unit);
         catch (InterruptedException e) 
            throw new RuntimeException(e);
        finally 
            // 7.释放锁
            unlock(lockKey);
        
        // 8.返回
        return r;
    

    private boolean tryLock(String key) 
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    

    private void unlock(String key) 
        stringRedisTemplate.delete(key);
    

以上是关于Redis的缓存问题之缓存穿透缓存雪崩缓存击穿的主要内容,如果未能解决你的问题,请参考以下文章

Redis之缓存穿透击穿雪崩问题与缓存删除淘汰策略

Redis——缓存穿透缓存击穿缓存雪崩分布式锁

Redis——缓存穿透缓存击穿缓存雪崩分布式锁

Redis——缓存穿透缓存击穿缓存雪崩

Redis缓存穿透击穿雪崩预热更新降级

Redis缓存穿透击穿雪崩预热更新降级