文章目录
- 缓存雪崩
- 缓存穿透
- 缓存击穿
缓存雪崩
缓存雪崩产生原因：由于缓存在同一时间大面积失效或者Redis宕机导致大量请求落入数据库，给数据库造成巨大的压力
解决方案：
1、当将数据添加到缓存中时，给缓存时间添加随机的过期时间。可以防止缓存在同一时间大面积失效。
2、使用Redis集群。当有节点宕机时使用其他节点恢复数据。
3、做好限级限流的策略
4、使用多级缓存
缓存穿透
缓存穿透产生原因：被恶意者攻击，发送大量不存在的数据请求，导致请求不会命中缓存，直接落到数据库，给数据库带来巨大的压力
解决方案：
1、缓存空值键到缓存中，适用于大量请求所带的id相同。为了避免内存的浪费，可以给空值键设置一个过期时间
优点：实现简单
缺点：当大量请求所带的id不同时，需要缓存多个空值键，占用额外的内存空间
保证空键值的实现：
@Autowired
private StringRedisTemplate redisTemplate;
public void set(String key, Object o, Long time, TimeUnit unit) {
redisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(o), time, unit);
}
/**
* 缓存空值键(解决缓存穿透)
*/
public <R, Id> R querySaveNull(String prefixKey, Id id, Class<R> type, Function<Id, R> dbFunction, Long time, TimeUnit unit) {
System.out.println("缓存空值");
String cacheKey = prefixKey + id;
String objectStr = redisTemplate.opsForValue().get(cacheKey);
if (StrUtil.isNotBlank(objectStr)) {
return JSONUtil.toBean(objectStr, type);
}
// shopStr不为null说明为'',即命中空值键的缓存
if (objectStr != null) {
return null;
}
R r = dbFunction.apply(id);
// 当查出来的数据为null时，往redis中添加空值的键
if (r == null) {
redisTemplate.opsForValue().set(cacheKey, "", CACHE_NULL_TTL,TimeUnit.SECONDS);
return null;
}
set(cacheKey,r,time,unit);
return r;
}
2、适用布隆过滤器。将数据库所有数据的id放入布隆过滤器中，当有请求到达时，先经过布隆过滤器，判断布隆过滤器中是否存在请求id，如果存在则通过，如果不存在则直接返回。
缺点：实现复杂，存在误差
3、可以增加id的复杂性，添加请求所带id的检验，可以防止被攻击者猜到id并发出攻击
缓存击穿
缓存击穿产生原因：存在高并发的热点键，并且其重建缓存业务复杂，重建缓存耗时长，当热点键过期失效时，大量线程进入重建缓存，查询数据库，导致数据库压力暴涨
解决方案：
1、基于互斥锁的实现。
基于Redis的setnx命令实现互斥锁，当数据不存在时可以添加数据成功，数据存在时添加数据失败，当线程适用setnx命令添加成功数据时则成功抢到了锁，添加失败则获取锁失败，线程执行结束后需要及时释放锁，为了防止因为其他原因锁没有被释放，可以给锁添加一个过期时间。
/**
* 获取互斥锁
*/
private Boolean getLock(String lockKey) {
// 返回的布尔类型使包装型，可能为null值，调用布尔工具类，当包装类为true时才返回true，否则返回false
Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
return BooleanUtil.isTrue(aBoolean);
}
/**
* 释放互斥锁
*/
private void releaseLock(String lockKey) {
redisTemplate.delete(lockKey);
}
当多线程到达时，首先查看能否命中缓存，如果缓存失效我们尝试让这些线程竞争锁，竞争到锁的线程负责进行缓存重建的业务，其他的线程则使其休眠一段时间后重新执行业务。以下是基于Shop对象的实现。
private Shop queryWithMutex(Long id) {
// 首先从缓存中查询数据
String cacheKey = CACHE_SHOP_KEY + id;
String shopStr = redisTemplate.opsForValue().get(cacheKey);
if (StrUtil.isNotBlank(shopStr)) {
return JSONUtil.toBean(shopStr, Shop.class);
}
String lockKey = LOCK_SHOP_KEY + id;
Boolean aBoolean = getLock(lockKey);
Shop shop = null;
// 如果获取锁失败，则进行递归重新执行
try {
if (!aBoolean) {
Thread.sleep(50);
return queryWithMutex(id);
}
Thread.sleep(500);
shop = getById(id);
// 当查出来的数据为null时，往redis中添加空值的键
if (shop == null) {
redisTemplate.opsForValue().set(cacheKey, "", CACHE_NULL_TTL, TimeUnit.SECONDS);
return null;
}
redisTemplate.opsForValue().set(cacheKey, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 当抛出异常或者业务执行完毕之后释放锁
releaseLock(lockKey);
}
return shop;
}
优点：保证了数据的高一致性，所有请求都能够返回最新的数据
缺点：重建缓存耗时较长，其他线程都需要等待缓存重建消耗的时间
2、基于逻辑过期实现。我们不给键添加过期时间，让其一直存在缓存中，但是我们在将数据其添加进缓存中时，会给其添加一个逻辑过期的字段，当多线程到达时，我们首先命中缓存，取出逻辑过期的字段，判断数据是否过期，如果数据过期，让线程竞争锁，获取到锁的线程新创建一个线程来进行缓存重建的业务，然后主线程和其他未竞争到锁的线程直接返回过期的数据。以下时基于Shop对象的实现
@Data
public class RedisData {
private LocalDateTime expireTime;
private Object data;
}
private Shop queryWithLogicalExpire(Long id) {
String key = CACHE_SHOP_KEY + id;
String redisDataStr = redisTemplate.opsForValue().get(key);
if (StrUtil.isBlank(redisDataStr)) {
return null;
}
RedisData redisData = JSONUtil.toBean(redisDataStr, RedisData.class);
Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
// 逻辑时间未过期
LocalDateTime expireTime = redisData.getExpireTime();
System.out.println(expireTime);
System.out.println(LocalDateTime.now());
if (expireTime.isAfter(LocalDateTime.now())) {
return shop;
}
// 逻辑时间过期后，竞争锁
String lockKey = LOCK_SHOP_KEY + id;
// 竞争成功锁的线程new线程来进行缓存重建
Boolean isLock = getLock(lockKey);
if (isLock){
executorService.execute(()->{
try {
Thread.sleep(500);
System.out.println("缓存重建");
saveShopRedis(id,CACHE_SHOP_TTL);
} catch (Exception e) {
e.printStackTrace();
} finally {
releaseLock(lockKey);
}
});
}
return shop;
}
/**
逻辑过期进行缓存重建
*/
public void saveShopRedis(Long id, Long time) {
String key = CACHE_SHOP_KEY + id;
Shop shop = getById(id);
RedisData redisData = new RedisData();
redisData.setData(shop);
redisData.setExpireTime(LocalDateTime.now().plusSeconds(time));
redisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}
优点：线程无需等待，直接返回数据
缺点：不保证数据的高一致性，部分线程可能返回以及过期的数据
