定义
同一时段大量的缓存key同时失效或者redis服务宕机，导致大量请求到达数据库，带来巨大压力。
解决方案
1.给不同key的TTL添加随机值。
2.利用redis集群提高服务的可用性。
3.给缓存业务添加降级限流策略。
4.给业务添加多级缓存。
缓存击穿
缓存击穿也叫做热点key问题，被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求会在瞬间给数据库带来巨大冲击。
解决方案
1.互斥锁
缺点：线程相互等待，性能差。可能有死锁风险。
优点：保证强一致性，没有额外的内存消耗，不用存储逻辑过期时间字段，实现简单。
2.逻辑过期
优点：线程无需等待，性能较好。不保证一致性，有额外内存消耗，实现复杂。
基于互斥锁方式解决缓存击穿
这里的互斥锁采用setnx命令，当这个key不存在的时候才能设置值，如果key已经存在了，则设置值失败。
127.0.0.1:6379> setnx lock 1
(integer) 1
127.0.0.1:6379> setnx lock 2
(integer) 0
127.0.0.1:6379> get lock
"1"
加锁是 setnx key 命令->赋值
释放锁 del key 命令->删除
如果设置锁，然后迟迟没有去删除，也就是没有释放锁。所以在设置setnx锁的时候，会加一个有效期。
/**
* 尝试加锁
* @return
*/
public boolean tryLock(String key) {
//setnx命令
Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
//这里会自动拆箱，防止flag为null报空指针异常
return BooleanUtil.isTrue(flag);
}
/**
* 释放锁
* @param key
*/
public void unLock(String key) {
stringRedisTemplate.delete(key);
} /**
* 防止缓存击穿-带互斥锁
* @return
*/
public Shop queryWithMutex(Long id) {
String key = RedisConstants.CACHE_SHOP_KEY + id;
//从redis中查询商铺缓存
String shopJsonStr = stringRedisTemplate.opsForValue().get(key);
//redis中有数据直接返回
if(StrUtil.isNotBlank(shopJsonStr)) {
return JSONUtil.toBean(shopJsonStr, Shop.class);
}
//判断命中的是否为空值
if(shopJsonStr != null) {
//说明命中空字符串,不会去查数据库
return null;
}
Shop shop = null;
String lockKey = "lock:shop:"+id;
try {
//未命中，实现缓存重建
//1.获取互斥锁
boolean isLock = tryLock(lockKey);
//2.判断是否获取互斥锁成功
//3.失败则休眠重试
if(!isLock) {
Thread.sleep(50);
return queryWithMutex(id);
}
//4.成功则，redis中没有数据，继续查询数据库
shop = getById(id);
if(ObjectUtil.isNull(shop)) {
//将空值写入redis
stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
//数据库没有查询到数据，返回错误
return null;
}
//数据库中查询到数据，存入redis，再返回数据;设置超时时间
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
}catch (Exception e) {
e.printStackTrace();
}finally {
//5.释放互斥锁
unLock(lockKey);
}
return shop;
}逻辑过期解决缓存击穿
向redis中添加数据时，额外添加一个时间字段。
逻辑过期，其实旧的数据还存在于redis中，只是是旧数据而已，还是可以在缓存重建的过程中返回旧数据。这样就不至于给数据库带来巨大压力。
缓存数据预热
@Data
public class RedisData {
/**
* 逻辑过期时间
*/
private LocalDateTime expireTime;
private Object data;
}/**
* 创造热点数据带逻辑过期，提前预热
* @param id
*/
public void saveShop2Redis(Long id, Long expiredSeconds) {
//1.查询店铺信息
Shop shop = getById(id);
//2.封装逻辑过期时间
String key = RedisConstants.CACHE_SHOP_KEY + id;
RedisData redisData = new RedisData();
redisData.setExpireTime(LocalDateTime.now().plusSeconds(expiredSeconds));
redisData.setData(shop);
//3.写入redis
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}@Test
void testSaveShop() {
shopService.saveShop2Redis(1L, 10L);
}redis中存储的店铺带逻辑过期时间
{
"data": {
"area": "北京",
"openHours": "10:00-22:00",
"sold": 4215,
"images": "https://qcloud.dpfile.com/pc/jiclIsCKmOI2arxKN1Uf0Hx3PucIJH8q0QSz-Z8llzcN56-_QiKuOvyio1OOxsRtFoXqu0G3iT2T27qat3WhLVEuLYk00OmSS1IdNpm8K8sG4JN9RIm2mTKcbLtc2o2vfCF2ubeXzk49OsGrXt_KYDCngOyCwZK-s3fqawWswzk.jpg,https://qcloud.dpfile.com/pc/IOf6VX3qaBgFXFVgp75w-KKJmWZjFc8GXDU8g9bQC6YGCpAmG00QbfT4vCCBj7njuzFvxlbkWx5uwqY2qcjixFEuLYk00OmSS1IdNpm8K8sG4JN9RIm2mTKcbLtc2o2vmIU_8ZGOT1OjpJmLxG6urQ.jpg",
"address": "北京王府井19号",
"comments": 3035,
"avgPrice": 80,
"updateTime": 1724455437000,
"score": 37,
"createTime": 1640167839000,
"name": "画画茶餐厅",
"x": 120.149192,
"y": 30.316078,
"typeId": 1,
"id": 1
},
"expireTime": 1725022878389
}
//创建线程池
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
/**
* 防止缓存击穿-逻辑过期+互斥锁
* @return
*/
public Shop queryWithLogicalExpired(Long id) {
String key = RedisConstants.CACHE_SHOP_KEY + id;
//从redis中查询商铺缓存
String shopJsonStr = stringRedisTemplate.opsForValue().get(key);
if(StrUtil.isBlank(shopJsonStr)) {
//不存在，直接返回
return null;
}
//redis中命中，需要将数据返序列化为java对象
RedisData redisData = JSONUtil.toBean(shopJsonStr, RedisData.class);
//判断是否逻辑过期
LocalDateTime expireTime = redisData.getExpireTime();
JSONObject data = (JSONObject)redisData.getData();
Shop shop = JSONUtil.toBean(data, Shop.class);
if(expireTime.isAfter(LocalDateTime.now())) {
//未过期，返回店铺信息
return shop;
}
//过期，需要重建缓存
//这里可能会有大量的线程在这里等着，只有一个线程能够获取锁去完成缓存重建，完成缓存重建后释放锁，其他线程还会获取锁
//所以在锁里面的逻辑需要再判断一次缓存是否过期，防止缓存反复的重建。
//1.获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
boolean lock = tryLock(lockKey);
if(lock) {
//获取锁成功
//需要重新从redis中获取数据，再判断一次缓存是否过期，防止缓存反复的重建，DoubleCheck
shopJsonStr = stringRedisTemplate.opsForValue().get(key);
redisData = JSONUtil.toBean(shopJsonStr, RedisData.class);
expireTime = redisData.getExpireTime();
if(expireTime.isAfter(LocalDateTime.now())) {
//未过期，返回店铺信息
return shop;
}
//使用线程池去完成缓存重建（独立的线程）
CACHE_REBUILD_EXECUTOR.submit(() -> {
try{
saveShop2Redis(id, 10L);
}catch (Exception e) {
e.printStackTrace();
}finally {
//在线程里面释放锁
unLock(lockKey);
}
});
}
//立即返回旧的逻辑过期数据
return shop;
}这里可能会有大量的线程在这里等着，只有一个线程能够获取锁去完成缓存重建，完成缓存重建后释放锁，其他线程还会获取锁.所以在锁里面的逻辑需要再判断一次缓存是否过期，防止缓存反复的重建。需要重新从redis中获取数据，再判断一次缓存是否过期，防止缓存反复的重建，DoubleCheck。
