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 queryShopById(Long id) {
if (id == null){
return Result.fail("店铺不存在");
}
Shop shop = cacheClient.queryWithSafety(CACHE_SHOP_KEY, LOCK_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
if(shop == null){
return Result.fail("店铺不存在");
}
return Result.ok(shop);
}工具包：
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();
}
}
}
都看到这啦，如果能帮助到你点个赞呗
扫一扫
408
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
