14、缓存预热+缓存雪崩+缓存击穿+缓存穿透

缓存预热+缓存雪崩+缓存击穿+缓存穿透

● 缓存预热、雪崩、穿透、击穿分别是什么？你遇到过那几个情况？
● 缓存预热你是怎么做到的？
● 如何避免或者减少缓存雪崩？
● 穿透和击穿有什么区别？它两一个意思还是截然不同？
● 穿透和击穿你有什么解决方案？如何避免？
● 加入出现了缓存不一致，你有哪些修补方案？

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 {@Autowiredprivate 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";@Autowiredprivate 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;}@PostConstructpublic void init() {log.info("启动定时器天猫聚划算功能模拟开始.........O(∩_∩)O");//用线程模拟定时任务，后台任务定时将mysql里面的参加活动的商品刷进redisnew 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";@Autowiredprivate 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网络抖动导致timeoutlog.error("jhs exception:{}",e);e.printStackTrace();//再次查询}return list;}}

至此步骤，上述聚划算的功能算是完成了，请思考在高并发情况下又会产生什么样的经典生产问题？
Bug和隐患说明

热点key突然失效导致可怕的缓存击穿：delete命令执行的一瞬间有空隙，其他请求线程找Redis为null，达到mysql，暴击mysql…
复习again

最终目的：2条命令原子性是其次的，主要是防止热点key突然失效暴击mysql打爆系统。
进一步升级加固案例
互斥更新—>双检加锁策略

差异失效时间，在本案例中给我们使用这个方式

    @PostConstructpublic void initJHSAB() {log.info("启动AB定时器天猫聚划算功能模拟开始.........O(∩_∩)O" + DateUtil.now());//用线程模拟定时任务，后台任务定时将mysql里面的参加活动的商品刷进redisnew 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网络抖动导致timeoutlog.error("jhs exception:{}", e);e.printStackTrace();//再次查询}return list;}