十分钟让你学会封装复用解决缓存穿透，击穿，雪崩问题

李温候

已于 2024-08-12 22:40:07 修改

阅读量730

点赞数 20

文章标签：缓存

于 2024-08-12 22:31:34 首次发布

本文链接：https://blog.csdn.net/weixin_64838846/article/details/141142692

版权

ps:我看一些课程，或者市面上也有类型的封装，但是感觉都差点意思，达不到自己的预期，所以自己干脆自己写一个工具包。

我们常见的并发线程安全问题

缓存击穿
- 概念：缓存击穿指的是缓存中没有但数据库中有的热点数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间飙升，造成过大压力。
缓存雪崩
- 概念：缓存雪崩是指大量缓存数据同时过期或被删除，导致缓存失效，使得大量请求直接访问数据库，可能导致数据库崩溃。
缓存穿透
- 概念：缓存穿透是指查询根本不存在的数据，导致缓存和存储层都不命中，每次请求都要查询数据库，失去缓存意义。

对于上面的问题，我本篇文章的解决方法如下：

缓存穿透，使用缓存空值 + 布隆过滤器 + 分布式锁 +双重检查的思想。

缓存击穿，使用布隆过滤器 + 分布式锁 +双重检查的思想

缓存雪崩，给redis过期时间数据额外加上一个随机时间

下面的例子，我用id查询商户为例

缓存空值

作用：有人恶意访问查询我们不存在的信息时，因为我们缓存和数据库中都没有数据，所以每次都会查询我们的数据库,大量的不存在问题请求，会压垮我们数据库，这时候我们就可以在第一次查询数据库的时候，查询的结果为空时，给我们对应的redis上缓存一个空的数据，这样就能防止大量请求用同一个id恶意访问同一个商户的情况(但是如果大量请求访问不同的不存在商户，上面的缓存空值也起不了作用，因为在我们处理之前，我们无法判断他们是不是合法请求)

            // MySQL 中不存在
            if (shop == null) {
                // 添加空对象(防止缓存穿透)
                stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, "",CACHE_NULL_TTL, TimeUnit.MINUTES);
                return Result.fail("店铺不存在");
            }

双重检查 + 锁

作用：双重检查锁时一种思想，懒汉式单例就有一种很经典的写法。双重检查锁的双重指的是判断两次（查询两次redis），锁的目的就是为了让同一时刻，只能有一个线程能进入到我们的临界区资源里面。然后我们使用了双重检查锁后，假如有大量请求打到我们服务器，双重检查锁只会让第一个请求（线程）进入到数据库，然后其他线程就会进入阻塞等待锁，当我们第一个请求查询到数据库之后，再把对应的数据存到缓存里，然后释放锁，但其它线程进入到我们的临界区资源时，会先让它判断缓存中是否有数据，有则直接return。

ps : 前面第一次查询缓存的过程略掉了,然后下面的代码拿到数据 和 拿到空值 都用到了双重判定的思想

// 使用分布式锁(防止缓存击穿)
        RLock lock = redissonClient.getLock(LOCK_SHOP_KEY + id);
        lock.lock(); // 获取不到锁一直等待
        try {
            // 双重判定的思想， 第一次请求查到数据后放入缓存，后续的请求拿到锁后，直接拿缓存数据返回即可
            // 拿到数据 和 拿到空值 都要用双重判定的思想
            shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
            // 拿到数据时
            if (StringUtils.isNotBlank(shopJson)) {
                // 有则直接返回
                return Result.ok(JSONUtil.toBean(shopJson, Shop.class));
            }
            // 拿到空值时
            if ("".equals(shopJson)) {
                return Result.fail("店铺不存在");
            }

            // redis 中没有数据，到 MySQL 中查找
            // Shop shop = this.query().eq("id", id).one();
            Shop shop = this.getById(id);
            // MySQL 中不存在
            if (shop == null) {
                // 添加空对象(防止缓存穿透)
                stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                return Result.fail("店铺不存在");
            }
            // MySQL中存在，将数据缓存进redis中
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);

ps:

懒汉式 - 双重检查锁定（Double-Checked Locking，DCL）
既保证了线程安全，又保证了性能。

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}

    public static Singleton getInstance() {
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }   
        return instance;
    }
}

如何使用引入分布式锁呢

很简单

1.导依赖

            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>xx.xx.xx</version>

2.类中使用

    private final RedissonClient redissonClient;

布隆过滤器

作用：能减少一些恶意请求访问我们的数据库。

特点：布隆过滤器判断存在的，不一定存在，判断不存在的，则一定不存在。

ps:

1. 我们在查询的时候使用布隆过滤器了，那么在对应的insert的方法内，插入数据的时候，需要把数据加到布隆过滤器里

2. 如果你是中途引入布隆过滤器的（数据库里面有数据了），那么需要给布隆过滤器预热（把对应信息加入到布隆过滤器里）

        // 判断布隆过滤器, 布隆过滤器里面没有的，则肯定不存在对应的数据
        if(!shopQueryBloomFilter.contains(id.toString())){
            return Result.fail("店铺不存在");
        }

如何使用引入布隆过滤器呢

1.配置布隆过滤器

/**
 * @author Blue sky
 * @Description 布隆过滤器配置
 */
@Configuration
@RequiredArgsConstructor
public class RBloomFilterConfiguration {
    private final RedissonClient redissonClient;
    /**
     * 查询商户的布隆过滤器 泛型改为String更通用一些，方便复用
     */
    @Bean
    public RBloomFilter<String> shopQueryCachePenetrationBloomFilter(RedissonClient redissonClient) {
        RBloomFilter<String> cachePenetrationBloomFilter = redissonClient.getBloomFilter("shopQueryCachePenetrationBloomFilter");
        cachePenetrationBloomFilter.tryInit(100000000L, 0.001);
        return cachePenetrationBloomFilter;
    }
}

2.类中使用

    private final RBloomFilter<String> shopQueryBloomFilter;

假如我们要查询一个商户信息，我们没有封装复用，我们的代码是这样子的

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result queryShopById(Long id) {
        // id为空直接返回
        if (id == null){
            return Result.fail("店铺不存在");
        }
        // 从 redis 中查询对应信息
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        // 是否不为空
        if (StringUtils.isNotBlank(shopJson)) {
            // 有则直接返回
            return Result.ok(JSONUtil.toBean(shopJson, Shop.class));
        }
        // 缓存为空时，还可能是空对象(防止缓存穿透)
        if ("".equals(shopJson)) {
            return Result.fail("店铺不存在");
        }
        // 判断布隆过滤器, 布隆过滤器里面没有的，则肯定不存在对应的数据
        if(!shopQueryBloomFilter.contains(id.toString())){
            return Result.fail("店铺不存在");
        }

        // 使用分布式锁(防止缓存击穿)
        RLock lock = redissonClient.getLock(LOCK_SHOP_KEY + id);
        lock.lock(); // 获取不到锁一直等待
        try {
            // 双重判定的思想， 第一次请求查到数据后放入缓存，后续的请求拿到锁后，直接拿缓存数据返回即可
            // 拿到数据 和 拿到空值 都要用双重判定的思想
            shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
            // 拿到数据时
            if (StringUtils.isNotBlank(shopJson)) {
                // 有则直接返回
                return Result.ok(JSONUtil.toBean(shopJson, Shop.class));
            }
            // 拿到空值时
            if ("".equals(shopJson)) {
                return Result.fail("店铺不存在");
            }

            // redis 中没有数据，到 MySQL 中查找
            // Shop shop = this.query().eq("id", id).one();
            Shop shop = this.getById(id);
            // MySQL 中不存在
            if (shop == null) {
                // 添加空对象(防止缓存穿透)
                stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                return Result.fail("店铺不存在");
            }
            // MySQL中存在，将数据缓存进redis中
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
            // 更新布隆过滤器
            shopQueryBloomFilter.add(id.toString());
            // 返回数据
            return Result.ok(shop);
        } finally {
            lock.unlock();
        }
    }

封装复用

@Override
    @Transactional(rollbackFor = Exception.class)
    public Result updateShop(Shop shop) {
        if (shop == null || shop.getId() == null) {
            return Result.fail("要修改的商铺为空 或 要修改的商铺id为空");
        }
        // 更新数据库
        this.updateById(shop);
        // 删除缓存
        stringRedisTemplate.delete(CACHE_SHOP_KEY + shop.getId());
        return null;
    }

工具包：

package com.hmdp.utils;

import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.hmdp.dto.Result;
import com.hmdp.entity.Shop;
import lombok.RequiredArgsConstructor;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.lang.reflect.Type;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static com.hmdp.utils.RedisConstants.*;

/**
 * @author Blue sky
 * @Description 自定义查询客户端
 */
@Component
@RequiredArgsConstructor
public class CacheClient{
    private final StringRedisTemplate stringRedisTemplate;
    private final RedissonClient redissonClient;
    private final RBloomFilter<String> rBloomFilter;


    /**
     * 安全的查询(解决缓存穿透，雪崩，击穿问题)
     * @param keyPrefix 查询的前缀
     * @param lockPrefix 分布式锁的前缀
     * @param queuyKey 查询条件字段
     * @param type 查找目标类的Class
     * @param dbFallback db数据库的查找方法
     * @param time redis的过期时间
     * @param unit 单位
     * @return
     * @param <R>  查找目标类的类型
     * @param <KEY> 查询字段的类型
     */
    public <R,KEY> R queryWithSafety(String keyPrefix, String lockPrefix,KEY queuyKey, Class<R> type,
                                     Function<KEY,R> dbFallback, Long time, TimeUnit unit){
        // 查询条件关键字不能为空
        if(queuyKey == null){
            return null;
        }
        // 从 redis 中查询对应信息
        String dataJson = stringRedisTemplate.opsForValue().get(keyPrefix + queuyKey);
        // 缓存是否不为空
        if (StringUtils.isNotBlank(dataJson)) {
            // 有则直接返回
            return JSONUtil.toBean(dataJson, type);
        }
        // 缓存为空时，还可能是空对象(防止缓存穿透)
        if ("".equals(dataJson)) {
            return null;
        }
        // 判断布隆过滤器, 布隆过滤器里面没有的，则肯定不存在对应的数据
        if(!rBloomFilter.contains(queuyKey.toString())){
            return null;
        }

        // 使用分布式锁(防止缓存击穿)
        RLock lock = redissonClient.getLock(lockPrefix + queuyKey);
        lock.lock(); // 获取不到锁一直等待
        try {
            // 双重判定的思想， 第一次请求查到数据后放入缓存，后续的请求拿到锁后，直接拿缓存数据返回即可
            // 拿到数据 和 拿到空值 都要用双重判定的思想
            dataJson = stringRedisTemplate.opsForValue().get(keyPrefix + queuyKey);
            // 拿到数据时
            if (StringUtils.isNotBlank(dataJson)) {
                // 有则直接返回
                JSONUtil.toBean(dataJson, type);
            }
            // 拿到空值时
            if ("".equals(dataJson)) {
                return null;
            }

            // redis 中没有数据，到 MySQL 中查找
            R data = dbFallback.apply(queuyKey);
            // MySQL 中不存在
            if (data == null) {
                // 添加空对象(防止缓存穿透)
                stringRedisTemplate.opsForValue().set(keyPrefix + queuyKey, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            // MySQL中存在，将数据缓存进redis中
            stringRedisTemplate.opsForValue().set(keyPrefix + queuyKey, JSONUtil.toJsonStr(data), time, unit);
            // 更新布隆过滤器
            rBloomFilter.add(queuyKey.toString());
            // 返回数据
            return data;
        } finally {
            lock.unlock();
        }
    }

}

都看到这啦，如果能帮助到你点个赞呗