缓存预热+缓存雪崩+缓存击穿+缓存穿透
● 缓存预热、雪崩、穿透、击穿分别是什么？你遇到过那几个情况？
● 缓存预热你是怎么做到的？
● 如何避免或者减少缓存雪崩？
● 穿透和击穿有什么区别？它两一个意思还是截然不同？
● 穿透和击穿你有什么解决方案？如何避免？
● 加入出现了缓存不一致，你有哪些修补方案？
1、缓存预热
2、缓存雪崩
发生原因
● Redis主机挂了，Redis全盘崩溃，偏硬件运维。
● Redis中有大量key同时过期大面积失效，偏软件开发。
预防＋解决
● Redis中key设置为永不过期or过期时间错开
● Redis缓存集群实现高可用
○ 主从＋哨兵
○ Redis Cluster
○ 开启Redis持久化机制RDB/AOF，尽快恢复缓存集群
● 多缓存结合预防雪崩
○ ehcache本地缓存+redis缓存
● 服务降级
○ Hystrix或者案例sentinel限流&降级
3、缓存穿透
发生原因
请求去查一条记录，先查Redis无，后查MySQL无，都查不到该条记录，但是请求每次都会打到数据库上面去，导致后台数据库压力暴增，这种就是缓存穿透。
简单来说就是本来无一物，两库都没有，既不在Redis缓存库，也不再MySQL，数据库存在被多次暴击风险
解决方案
方案一：空对象缓存或者缺省值
一般正常情况下使用回写增强：mysql也查不到的话就让redis存入刚刚查不到的key并保护mysql，第一次来查询没有查询到，redis和mysql都没有，返回null给调用者，但是增强回写后第二次查同样的key，此时redis就有值了，可以直接从redis中读取default缺省值返回给业务程序，避免了把大量请求发送给mysql处理，打爆mysql------------>此种方法架不住黑客的恶意攻击，有缺陷…只能解决key相同的情况。
黑客或者恶意攻击：黑客会对你的系统进行攻击，拿一个不存在的id去查询数据，会产生大量的请求到数据库查询，可能会导致你的数据库由于压力过大而宕机。
key相同—>第一次达到mysql，空对象缓存后第二次就返回default缺省值，避免mysql再被攻击，不用再到数据库中走一圈了。
key不同—>由于存在空对象缓存和缓存回写（看自己的业务），redis中无关紧张的key也会越来越多（记得设置redis过期时间）。
方案二：Google布隆过滤器Guava解决缓存穿透
Guava中布隆过滤器的实现算是比较权威的，所以实际项目中可以直接采用Guava布隆过滤器
白名单过滤器实战
白名单那过滤器架构说明
误判问题：概率小还可以接受，不能从布隆过滤器中删除
全部合法的key都需要放入Guava版布隆过滤器+Redis里面，不然数据就是返回null
改POM
<!-- Guava Google开源的Guava中自带的布隆过滤器-->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>23.0</version>
</dependency>
业务类
我们的目的是再白名单里面设置100w的数据，然后再额外加入10w的数据，看一下误判率是多少
/**
* @author Guanghao Wei
* @create 2023-04-25 14:51
*/
@Service
@Slf4j
public class GuavaWithBloomFilterService {
//定义常量
public static final int _1W = 10000;
//定义guava布隆过滤器初始容量
public static final int SIZE = 100 * _1W;
//误判率，它越小，误判个数越少
public static double fpp = 0.03;
//创建guava布隆过滤器
private BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), SIZE, fpp);
public void guavaBloomFilter() {
//先让bloomFilter加入100w数据
for (int i = 1; i <= SIZE; i++) {
bloomFilter.put(i);
}
//故意取10w个不在合法范围内的数据
ArrayList<Object> list = new ArrayList<>(10 * _1W);
//验证
for (int i = SIZE + 1; i <= SIZE + (10 * _1W); i++) {
if (bloomFilter.mightContain(i)) {
log.info("被误判了：{}", i);
list.add(i);
}
}
log.info("误判总数量：{}", list.size());
}
}
/**
* @author Guanghao Wei
* @create 2023-04-25 14:51
*/
@Api(tags = "google工具Guava处理布隆过滤器")
@RestController
@Slf4j
public class GuavaWithBloomFilterController {
@Autowired
private GuavaWithBloomFilterService guavaWithBloomFilterService;
@ApiOperation("guava布隆过滤器插入100万样本数据并额外添加10w测试是否存在")
@GetMapping("guavafilter")
public void guavaBloomFilter() {
guavaWithBloomFilterService.guavaBloomFilter();
}
}
这里有一个误判率的知识点我们通过debug源码来学习：
布隆过滤器说明
缓存击穿
是什么
大量的请求同时查询一个key时，此时这个key正好失效了，就会导致大量的请求都打到数据库上去
简单来说就是热点key突然失效了，暴打mysql。
穿透和击穿，截然不同
热点key为什么失效？
时间到了自然清除但还未被访问到
delete掉的key，刚巧又被访问
危害
会造成某一时刻数据库请求量过大，压力剧增
一般技术部门需要知道热点key是哪些，做到心里有数防止击穿
解决
方案一:差异失效时间
对于访问频繁的热点key，干脆就不设置过期时间
方案二：互斥更新
采用双检加锁策略
案例
天猫聚划算功能实现+防止缓存击穿
数据类型可以选用list和zset，但这类场景一般还是选择list
实体类
/**
* @author Guanghao Wei
* @create 2023-04-25 15:40
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "聚划算活动product信息")
public class Product {
private Long id;
private String name;
private Integer price;
private String detail;
}
service
/**
* @author Guanghao Wei
* @create 2023-04-25 15:42
*/
@Service
@Slf4j
public class JHSTaskService {
public static final String JHS_KEY = "jhs";
public static final String JHS_KEY_A = "jhs:a";
public static final String JHS_KEY_B = "jhs:b";
@Autowired
private RedisTemplate redisTemplate;
/**
* 模拟从数据库读取20件特价商品，用于加载到聚划算的页面中
*
* @return
*/
private List<Product> getProductsFromMysql() {
List<Product> list = new ArrayList<>();
for (int i = 1; i <= 20; i++) {
Random random = new Random();
int id = random.nextInt(10000);
Product obj = new Product((long) id, "product" + i, i, "detail");
list.add(obj);
}
return list;
}
@PostConstruct
public void init() {
log.info("启动定时器天猫聚划算功能模拟开始.........O(∩_∩)O");
//用线程模拟定时任务，后台任务定时将mysql里面的参加活动的商品刷进redis
new Thread(() -> {
//模拟从mysql查出数据用于加载进redis，在页面展示
List<Product> productList = this.getProductsFromMysql();
//采用redis list数据结构的lpush命令来存储
redisTemplate.delete(JHS_KEY);
//加入最新的数据
redisTemplate.opsForList().leftPushAll(JHS_KEY, productList);
//暂停1分钟，间隔一分钟执行一次，模拟聚划算一天执行的参加活动的品牌
try { TimeUnit.MINUTES.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
}, "t1").start();
}
}
controller
/**
* @author Guanghao Wei
* @create 2023-04-25 15:42
*/
@Api(tags = "聚划算页面展示控制器")
@RestController
@Slf4j
public class JHSProductController {
public static final String JHS_KEY = "jhs";
@Autowired
private RedisTemplate redisTemplate;
/**
* 分页查询，在高并发的情况下，只能走Redis查询，走db的话必定会吧db打垮
*
* @param page
* @param size
* @return
*/
@ApiOperation("聚划算案例，每次1页展示5条数据")
@GetMapping("product/find")
public List<Product> find(int page, int size) {
List<Product> list = null;
long start = (page - 1) * size;
long end = start + size - 1;
try {
list = redisTemplate.opsForList().range(JHS_KEY, start, end);
if (CollectionUtils.isEmpty(list)) {
//走数据库查询 TODO
}
log.info("参加活动的商家：{}",list);
} catch (Exception e) {
//出异常了，一般redis宕机了，或者redis网络抖动导致timeout
log.error("jhs exception:{}",e);
e.printStackTrace();
//再次查询
}
return list;
}
}
至此步骤，上述聚划算的功能算是完成了，请思考在高并发情况下又会产生什么样的经典生产问题？
Bug和隐患说明
热点key突然失效导致可怕的缓存击穿：delete命令执行的一瞬间有空隙，其他请求线程找Redis为null，达到mysql，暴击mysql…
复习again
最终目的：2条命令原子性是其次的，主要是防止热点key突然失效暴击mysql打爆系统。
进一步升级加固案例
互斥更新—>双检加锁策略
差异失效时间，在本案例中给我们使用这个方式
@PostConstruct
public void initJHSAB() {
log.info("启动AB定时器天猫聚划算功能模拟开始.........O(∩_∩)O" + DateUtil.now());
//用线程模拟定时任务，后台任务定时将mysql里面的参加活动的商品刷进redis
new Thread(() -> {
//模拟从mysql查出数据用于加载进redis，在页面展示
List<Product> productList = this.getProductsFromMysql();
//先更新B缓存，且让B过期时间超过A，B做兜底
redisTemplate.delete(JHS_KEY_B);
redisTemplate.opsForList().leftPushAll(JHS_KEY_B, productList);
redisTemplate.expire(JHS_KEY_B, 86410L, TimeUnit.SECONDS);
//在更新A缓存
redisTemplate.delete(JHS_KEY_A);
redisTemplate.opsForList().leftPushAll(JHS_KEY_A, productList);
redisTemplate.expire(JHS_KEY_A, 86400L, TimeUnit.SECONDS);
//暂停1分钟，间隔一分钟执行一次，模拟聚划算一天执行的参加活动的品牌
try { TimeUnit.MINUTES.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
}, "t1").start();
}
@ApiOperation("AB双缓存架构，防止热点key突然失效")
@GetMapping("product/findAB")
public List<Product> findAB(int page, int size) {
List<Product> list = null;
long start = (page - 1) * size;
long end = start + size - 1;
try {
list = redisTemplate.opsForList().range(JHS_KEY_A, start, end);
if (CollectionUtils.isEmpty(list)) {
log.info("-------A缓存已经失效或者过期了，记得人工修改，B缓存继续顶着");
list = redisTemplate.opsForList().range(JHS_KEY_B, start, end);
if (CollectionUtils.isEmpty(list)) {
//TODO 走数据库查询
}
}
} catch (Exception e) {
//出异常了，一般redis宕机了，或者redis网络抖动导致timeout
log.error("jhs exception:{}", e);
e.printStackTrace();
//再次查询
}
return list;
}
![[Linux]进程状态](https://img-blog.csdnimg.cn/img_convert/614aa0b42da3b307584a75d3f2bdc117.png)
