Redis 缓存穿透击穿和雪崩

快乐的小三菊

已于 2024-06-19 14:27:29 修改

阅读量522

点赞数

分类专栏： redis 文章标签： redis

于 2019-07-25 16:33:23 首次发布

本文链接：https://blog.csdn.net/xhf852963/article/details/97272178

版权

redis 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

一、缓存穿透

1.1 缓存穿透概念

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

1.2 解决方案

常见的解决方案有两种，分别为缓存空对象和布隆过滤

1.2.1 缓存空对象

缓存空对象的优点为实现简单，维护方便；缺点为会造成额外的内存消耗、造成短期的数据不一致问题。整体架构如下图：

1.2.2 布隆过滤器

布隆过滤器的优点为内存占用少，没有多余 key；缺点为实现复杂，存在误判的可能。整体架构如下图：

1.3 案例演示

修改 ShopController 中的业务逻辑，通过缓存空对象来解决缓存穿透的问题，整体的架构图如下所示：

代码如下：

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryShopById(Long id) {

        String key = "cache:shop:"+id;
        // 1、从 redis 查询商铺缓存
        String s = stringRedisTemplate.opsForValue().get(key);
        // 2、判断是否存在
        if(StrUtil.isNotBlank(s)){
            // 3、存在，直接返回
            Shop shop = JSONUtil.toBean(s, Shop.class);
            return Result.ok(shop);
        }
        // 判断是否命中的是空值
        if(s != null){
            // 返回错误信息
            return Result.fail("店铺信息不存在");
        }
        // 4、不存在，根据 id 查询数据库
        Shop shop = getById(id);
        // 5、不存在，直接返回错误信息
        if(shop == null){
            // 将空值写入 redis，并设置有效期
            stringRedisTemplate.opsForValue().set(key,"",2,TimeUnit.MINUTES);
            return Result.fail("店铺不存在");
        }
        // 6、存在，写入 redis
        String s1 = JSONUtil.toJsonStr(shop);
        // 7、返回
        stringRedisTemplate.opsForValue().set(key,s1,30, TimeUnit.MINUTES);
        return Result.ok(shop);
    }

1.4 总结

问：缓存穿透产生的原因是什么？

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

问：缓存穿透的解决方案有哪些？

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

二、缓存雪崩

2.1 缓存雪崩概念

缓存雪崩是指在同一时段大量的缓存 key 同时失效或者 Redis 服务宕机，导致大量请求到达数据库，带来巨大压力。

2.2 解决方案

1、给不同的 Key 的 TTL 添加随机值

2、利用 Redis 集群提高服务的可用性

3、给缓存业务添加降级限流策略

4、给业务添加多级缓存

三、缓存击穿

3.1 缓存击穿概念

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

3.2 解决方案

常见的解决方案有两种，一种是互斥锁，一种是逻辑过期。

3.2.1 互斥锁

线程 1 发现缓存未命中则先获取锁，只有获取锁成功了才可以重建缓存数据，重建完成后将数据写入缓存，最后释放锁。其他的线程（线程2）在释放锁之前只能不断重试，只有等到线程1释放锁之后才可以命中缓存。

当有无数的请求都并发的执行下图种的业务，只会有一个线程来完成这个任务，其他的线程都是等待，阻塞和重试。

这种方式最大的问题就是互相等待，性能可能会差一些。

3.2.2 逻辑过期

逻辑过期可以认为是永不过期，设置 key 时不设置过期时间，但是在存储数据的时候多添加一个 expire 时间（当前时间 + TTL 时间），用于记录这个 key 理论上的过期时间。

当线程1查询缓存发现逻辑时间已过期了，为了避免其他线程也来重新缓存，此时也需要获取锁，为了避免获取锁等待的时间过长，会开启一个新的线程（线程2）去做查询数据和缓存重建的功能。

在线程2写入缓存之前的这一段时间，其他的线程则返回过期数据返回，不再等待。

3.2.3 两种方式对比

解决方案	互斥锁	逻辑过期
优点	没有额外的内存消耗；保证一致性；实现简单	线程无需等待，性能较好
缺点	线程需要等待，性能受影响；可能有死锁风险	不保证一致性；有额外内存消耗；实现复杂

3.3 互斥锁解决缓存击穿

3.3.1 流程图

接下来我们基于互斥锁的方式解决缓存击穿问题，修改根据 id 查询商铺的业务，基于互斥锁方式来解决缓存击穿问题。整体流程图如下：

3.3.2 代码实现

下面的代码既解决了缓存穿透，又解决了缓存击穿的问题，代码如下：

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryShopById(Long id) {

        // 用互斥锁解决缓存击穿
        Shop shop = queryWithMutex(id);
        if (shop == null) {
            return  Result.fail("店铺不存在");
        }
        return Result.ok(shop);
    }

    // 用互斥锁解决缓存击穿问题
    public Shop  queryWithMutex(Long id){
        String key = "cache:shop:"+id;
        // 1、从 redis 查询商铺缓存
        String s = stringRedisTemplate.opsForValue().get(key);
        // 2、判断是否存在
        if(StrUtil.isNotBlank(s)){
            // 3、存在，直接返回
            Shop shop = JSONUtil.toBean(s, Shop.class);
            return shop;
        }
        // 4、判断是否命中的是空值
        if(s != null){
            // 返回错误信息
            return null;
        }
        // 5、实现缓存重建
        // 5.1 获取互斥锁
        String lockKey = null;
        Shop shop = null;
        try {
            lockKey = "lock:shop:"+id;
            boolean isLock = tryLock(lockKey);
            // 5.2 判断获取是否成功
            if(!isLock){
                // 5.3 获取失败，休眠并重试
                Thread.sleep(50);
                return queryWithMutex(id);
            }
            // 5.4 获取锁成功后应该再次监测 redis 缓存是否存在，如果存在则无需创建
            String s2 = stringRedisTemplate.opsForValue().get(key);
            if(StrUtil.isNotBlank(s2)) {
                shop = JSONUtil.toBean(s2, Shop.class);
                return shop;
            }
            // 5.5 获取成功之后，根据 id 查询数据库
            shop = getById(id);
            // 模拟重建延迟，可以使用 jmeter 进行压力测试，看看是否存在并发问题，若测试，则打开下面的注释
            // Thread.sleep(200);
            // 6、不存在，直接返回错误信息
            if(shop == null){
                // 6.1 将空值写入 redis，并设置有效期
                stringRedisTemplate.opsForValue().set(key,"",2,TimeUnit.MINUTES);
                return null;
            }
            // 7、存在，写入 redis
            String s1 = JSONUtil.toJsonStr(shop);
            stringRedisTemplate.opsForValue().set(key,s1,30, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 8、释放互斥锁
            unlock(lockKey);
        }
        // 9、返回
        return shop;
    }
	// 自定义互斥锁的加锁方法，其实就是使用 redis 的 setnx 命令
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }
    // 自定义互斥锁的解锁方法
    private boolean unlock(String key){
        Boolean flag = stringRedisTemplate.delete(key);
        return BooleanUtil.isTrue(flag);
    }
}

3.4 逻辑过期解决缓存击穿

3.4.1 流程图

接下来我们基于逻辑过期的方式解决缓存击穿问题，修改根据 id 查询商铺的业务，基于逻辑过期方式来解决缓存击穿问题。整体流程图如下：

3.4.2 代码实现

首先封装一个类用于接收对象和过期时间，代码如下：

@Data
public class RedisData {
    private LocalDateTime expire;

    private Object data;
}

然后编写基于逻辑过期解决缓存击穿的代码，如下：

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryShopById(Long id) {
		// 用逻辑过期时间解决缓存穿透问题
        Shop shop = queryWithLogicExpire(id);
        if (shop == null) {
            return  Result.fail("店铺不存在");
        }

        return Result.ok(shop);
    }
    private static final  ExecutorService CACHE_REBUILD_EXECUTOR  = Executors.newFixedThreadPool(10);
    // 用逻辑过期时间解决缓存击穿问题
    public Shop  queryWithLogicExpire(Long id){
        String key = "cache:shop:"+id;
        // 1、从 redis 查询商铺缓存
        String s = stringRedisTemplate.opsForValue().get(key);
        // 2、判断是否存在
        if(StrUtil.isBlank(s)){
            // 3、未命中，直接返回
            return null;
        }
        // 4、命中，先把 json 序列化成对象
        RedisData redisData = JSONUtil.toBean(s, RedisData.class);
        // 由于 RedisData 的属性为 Object 类型，所以被转换成了 JSONObject 类型
        JSONObject data = (JSONObject)redisData.getData();
        Shop shop = JSONUtil.toBean(data, Shop.class);

        LocalDateTime expireTime = redisData.getExpire();
        // 5、判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())) {
            // 5.1 未过期，直接返回店铺信息
            return shop;
        }
        // 5.2 已过期，需要缓存重建
        // 6、缓存重建
        // 6.1 获取互斥锁
        String locoKey = "lock:shop:"+id;
        boolean isLock = tryLock(locoKey);
        // 6.2 判断是否获取锁成功
        if(isLock){
            // 6.3 再次判断是否 redis 是否过期，双重检查
            if(expireTime.isAfter(LocalDateTime.now())) {
                // 5.1 未过期，直接返回店铺信息
                return shop;
            }
            // 6.4 若已过期，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() ->{
                try {
                    // 重建缓存，并设置过期时间
                    this.save2Redis(id,30000L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unlock(locoKey);
                }
            });
        }
        // 6.4 失败，返回过期的商铺信息
        return shop;
    }
    // 创建一个存放热点 key 的方法
    public void save2Redis(Long id,Long expireSeconds) throws InterruptedException {
        // 1、查询店铺数据
        Shop shop = getById(id);
        // 2、封装逻辑过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpire(LocalDateTime.now().plusSeconds(expireSeconds));
        // 3、写入 Redis
        stringRedisTemplate.opsForValue().set("cache:shop:"+id,JSONUtil.toJsonStr(redisData));
    }
    // 自定义互斥锁的加锁方法
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }
    // 自定义互斥锁的解锁方法
    private boolean unlock(String key){
        Boolean flag = stringRedisTemplate.delete(key);
        return BooleanUtil.isTrue(flag);
    }

}

四、缓存工具封装

4.1 功能描述

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

方法一：将任意 Java 对象序列化为 json 并存储在 string 类型的 key 中，并且可以设置 TTL 过期时间。

方法二：将任意 Java 对象序列化为 json 并存储在 string 类型的 key 中，并且可以设置逻辑过期时间，用于处理缓存击穿问题。

方法三：根据指定的 key 查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题。

方法四：根据指定的 key 查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

4.2 代码实现

@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);
    }
}

调用代码如下：

    @Override
    public Result queryById(Long id) {
        // 解决缓存穿透，第一个参数为缓存 key 的前缀
        Shop shop = cacheClient
                .queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);

        // 互斥锁解决缓存击穿
        // Shop shop = cacheClient
        //         .queryWithMutex(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);

        // 逻辑过期解决缓存击穿
        // Shop shop = cacheClient
        //         .queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, 20L, TimeUnit.SECONDS);

        if (shop == null) {
            return Result.fail("店铺不存在！");
        }
        // 7.返回
        return Result.ok(shop);
    }