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();
}
}
}
都看到这啦,如果能帮助到你点个赞呗