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

面试题：

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

缓存预热

@PostConstruct初始化白名单数据

详情地址可查看代码：Redis BitMap/HyperLogLog/GEO/布隆过滤器案例_Please Sit Down的博客-CSDN博客

缓存雪崩

出现原因

redis主机挂了，redis全盘崩溃，偏硬件运维
redis中有大量key同时过期大面积失效，偏软件开发

缓存＋解决

1、redis中key设置为永不过期 or 过期时间错开

2、redis缓存集群实现高可用

a、主从+哨兵
b、使用Redis集群
c、开启redis持久化机制aof/rdb，尽快恢复缓存集群

3、多缓存结合预防雪崩

ehcache本地缓存 + redis缓存

4、服务降级

Hystrix或者阿里sentinel限流&降级

缓存穿透

是什么

请求去查询一条记录，先查redis无，后查mysq无，都查询不到该条记录，但是清求每次都会打到数据库上面去，导致后台数据库压力暴增。这种现象我们称为缓存穿适，这个redis变成了一个摆设。

简单说就是：本来无物，两库都没有。既不在Redis缓存库，也不在mysql，数据车存在被多次暴击风险。

解决

主要是防止恶意攻击，解决方法：空对象缓存、bloomfilteri过滤器

方案一

空对象缓存或者缺省值。

第一种解决方案，回写增强。如果发生了缓存穿透，我们可以针对要查询的数据，在Redis里存一个和业务部门商量后确定的缺省值(比如，零、负数、defaultNull等)。

比如，键uid:abcdxxx，值defaultNull作为案例的key和value。先去redis查键uid:abcdxxx没有，再去mysql查没有获得，这就发生了一次穿透现象。but，可以增强回写机制。mysql也查不到的话也让redis存入刚刚查不到的key并保护mysql。第一次来查询uid:abcdxxx，redis和mysql都没有，返回null给调用者，但是增强回写后第二次来查uid:abcdxxx，此时redis就有值了。可以直接从Redis中读取default缺省值返回给业务应用程序，避免了把大量请求发送给mysql处理，打爆mysql。但是，此方法架不住黑客的恶意攻击，有缺陷......，只能解决key相同的情况。

黑客或者恶意攻击：黑客会对你的系统进行攻击，拿一个不存在的id去查询数据，会产生大量的情求到数据库去查询。可能会导数你的数据库由于压力过大而宕掉。

1、key相同打你系统：第一次打到mysql，空对象缓存后第二次就返回defaultNull缺省值，避免mysql被攻击，不用再到数据车中去走一圈了。

2、key不同打你系统：由于存在空对象缓存和缓存回写（看自己业务不限死）,redis中的无关紧要的key也会越写越多(记得设置redisi过期时间)

方案二

使用Google布隆过器Guava解决缓存穿透。

Guava中布隆过滤器的实现算是比较权威的，所以实际项目中我们可以直接使用Guava布隆过滤器。

Guava's BloomFilter源码出处：https://github.com/google/guava/blob/master/guava/src/com/google/common/hash/BloomFilter.java

白名单过滤器案例：

说明：会出现误判问题，但是概率小可以接受，不能从布隆过滤器删除；全部合法的key都需要放入Guava版布隆过滤器+redis里面，不然数据就是返回null。

代码实现：

pom.xml


<dependency>
   <groupId>com.google.guavagroupId>
   <artifactId>guavaartifactId>
   <version>23.0version>
dependency>

yml


server.port=7777
spring.application.name=redis7
 
# ========================redis单机=====================
spring.redis.database=0
# 修改为自己真实IP
spring.redis.host=192.168.111.185
spring.redis.port=6379
spring.redis.password=111111
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

测试1：


@Test
public void testGuavaWithBloomFilter(){
    // 创建布隆过滤器对象
    BloomFilter filter = BloomFilter.create(Funnels.integerFunnel(), 100);
    // 判断指定元素是否存在
    System.out.println(filter.mightContain(1));
    System.out.println(filter.mightContain(2));
    // 将元素添加进布隆过滤器
    filter.put(1);
    filter.put(2);
    System.out.println(filter.mightContain(1));
    System.out.println(filter.mightContain(2));
}
 
// 结果
// false false 
 
// true true

测试2：取样本100W数据，查查不在100W范围内，其它10W数据是否存在

controller


import com.atguigu.redis7.service.GuavaBloomFilterService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
 
import javax.annotation.Resource;
 
@Api(tags = "google工具Guava处理布隆过滤器")
@RestController
@Slf4j
public class GuavaBloomFilterController{
    @Resource
    private GuavaBloomFilterService guavaBloomFilterService;
 
    @ApiOperation("guava布隆过滤器插入100万样本数据并额外10W测试是否存在")
    @RequestMapping(value = "/guavafilter",method = RequestMethod.GET)
    public void guavaBloomFilter() {
        guavaBloomFilterService.guavaBloomFilter();
    }
}

service


import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
 
import java.util.ArrayList;
import java.util.List;
 
@Service
@Slf4j
public class GuavaBloomFilterService{
    public static final int _1W = 10000;
    //布隆过滤器里预计要插入多少数据
    public static int size = 100 * _1W;
    //误判率,它越小误判的个数也就越少(思考，是不是可以设置的无限小，没有误判岂不更好)
    //fpp the desired false positive probability
    public static double fpp = 0.03;
    // 构建布隆过滤器
    private static BloomFilter bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size,fpp);
    public void guavaBloomFilter(){
        //1 先往布隆过滤器里面插入100万的样本数据
        for (int i = 1; i <=size; i++) {
            bloomFilter.put(i);
        }
        //故意取10万个不在过滤器里的值，看看有多少个会被认为在过滤器里
        List 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());
    }
}

结果：

现在总共有10万数据是不存在的，误判了3033次，原始样本：100W

不存在数据:1000000W---1100000W

误判率：3033 / 100000 = 0.03033

深刻分析代码：核心BloomFilter.create方法


@VisibleForTesting
  static  BloomFilter create(
      Funnelsuper T> funnel, long expectedInsertions, double fpp, Strategy strategy) {
    。。。。
}

这里有四个参数：

funnel：数据类型(通常是调用Funnels工具类中的)
expectedInsertions：指望插入的值的个数
fpp：误判率(默认值为0.03)
strategy：哈希算法

问题：为什么fpp设置成0.03？

情景一：fpp = 0.01

误判个数：947

占内存大小：9585058位数
解决的hash冲突函数：7个

情景二：fpp = 0.03（默认参数）

误判个数：3033

占内存大小：7298440位数
解决的hash冲突函数：5个

情景三：fpp=0.000000000000001

占用内存大小：67095408位数
解决的hash冲突函数：47个

情景总结：

误判率能够经过fpp参数进行调节
fpp越小，须要的内存空间就越大：0.01须要900多万位数，0.03须要700多万位数。
fpp越小，集合添加数据时，就须要更多的hash函数运算更多的hash值，去存储到对应的数组下标里。（忘了去看上面的布隆过滤存入数据的过程）

上面的numBits，表示存一百万个int类型数字，须要的位数为7298440，700多万位。理论上存一百万个数，一个int是4字节32位，须要481000000=3200万位。若是使用HashMap去存，按HashMap50%的存储效率，须要6400万位。能够看出BloomFilter的存储空间很小，只有HashMap的1/10左右。

上面的numHashFunctions表示须要几个hash函数运算，去映射不一样的下标存这些数字是否存在（0 or 1）。

布隆过滤器说明：

黑名单过滤器案例：

缓存击穿

是什么

大量的请求同时查询一个key时，此时这个key正好失效了，就会导致大量的请求都打到数据库上面去。简单说就是热点key突然失效了，暴打mysql

备注：穿透和击穿，截然不同。

危害

会造成某一时刻数据库请求量过大，压力剧增。

一般技术部门需要知道热点key是那些个？做到心里有数防止击穿

解决

互斥更新、随机退避、差异失效时间

热点key失效问题：时间到了自然清除但还波访问到；delete掉的key，刚I巧又被访问

方案1：差异失效时间，对于访问须繁的热点key，干脆就不设置过期时间

方案2：互斥跟新，采用双检加锁策略

多个线程同时去查询数据库的这条数据，那么我们可以在第一个查询数据的请求上使用一个互斥锁来锁住它。其他的线程走到这一步拿不到锁就等着，等第一个线程查询到了数据，然后做缓存。后面的线程进来发现已经有缓存了，就直接走缓存。

案例

天猫聚划算功能实现+防止缓存击穿（热点key突然失效导致了缓存击穿）

定时任务每次取20条记录，取的过程中，突然失效，大量数据打到mysql

redis数据类型选型：list

常规代码

entity


import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
 
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "聚划算活动producet信息")
public class Product {
    //产品ID
    private Long id;
    //产品名称
    private String name;
    //产品价格
    private Integer price;
    //产品详情
    private String detail;
}

service：采用定时器将参与聚划算活动的特价商品新增进入redis中


import cn.hutool.core.date.DateUtil;
import com.atguigu.redis7.entities.Product;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
 
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;
 
@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;
 
    /**
     * 偷个懒不加mybatis了，模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
     * @return
     */
    private List getProductsFromMysql() {
        List list=new ArrayList<>();
        for (int i = 1; i <=20; i++) {
            Random rand = new Random();
            int id= rand.nextInt(10000);
            Product obj=new Product((long) id,"product"+i,i,"detail");
            list.add(obj);
        }
        return list;
    }
 
    @PostConstruct
    public void initJHS(){
        log.info("启动定时器淘宝聚划算功能模拟.........."+ DateUtil.now());
        new Thread(() -> {
            //模拟定时器一个后台任务，定时把数据库的特价商品，刷新到redis中
            while (true){
                //模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
                List list=this.getProductsFromMysql();
                //采用redis list数据结构的lpush来实现存储
                this.redisTemplate.delete(JHS_KEY);
                //lpush命令
                this.redisTemplate.opsForList().leftPushAll(JHS_KEY,list);
                //间隔一分钟 执行一遍，模拟聚划算每3天刷新一批次参加活动
                try { TimeUnit.MINUTES.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
 
                log.info("runJhs定时刷新..............");
            }
        },"t1").start();
    }
}

controller


import com.atguigu.redis7.entities.Product;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
 
@RestController
@Slf4j
@Api(tags = "聚划算商品列表接口")
public class JHSProductController {
    public  static final String JHS_KEY="jhs";
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    /**
     * 分页查询：在高并发的情况下，只能走redis查询，走db的话必定会把db打垮
     * @param page
     * @param size
     * @return
     */
    @RequestMapping(value = "/pruduct/find",method = RequestMethod.GET)
    @ApiOperation("按照分页和每页显示容量，点击查看")
    public List find(int page, int size) {
        List list=null;
 
        long start = (page - 1) * size;
        long end = start + size - 1;
 
        try {
            //采用redis list数据结构的lrange命令实现分页查询
            list = this.redisTemplate.opsForList().range(JHS_KEY, start, end);
            if (CollectionUtils.isEmpty(list)) {
                //TODO 走DB查询
            }
            log.info("查询结果：{}", list);
        } catch (Exception ex) {
            //这里的异常，一般是redis瘫痪 ，或 redis网络timeout
            log.error("exception:", ex);
            //TODO 走DB查询
        }
 
        return list;
    }
}

至此步骤，上述聚划算的功能算是完成，请思考在高并发下有什么经典生产问题？

答案：热点k突然失效导致可怕的缓存击穿，delete命令执行的一瞬间有空隙，其它请求线程继续找Redis为null，打到了mysql，暴击…

最终目的：2条命令原子性还是其次，主要是防止热key突然失效暴击mysq打爆系统

加固代码

采用差异失效时间

sevice


import cn.hutool.core.date.DateUtil;
import com.atguigu.redis7.entities.Product;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;
 
@Service
@Slf4j
public class JHSTaskService {
    public  static final String JHS_KEY_A="jhs:a";
    public  static final String JHS_KEY_B="jhs:b";
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    /**
     * 偷个懒不加mybatis了，模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
     * @return
     */
    private List getProductsFromMysql() {
        List list=new ArrayList<>();
        for (int i = 1; i <=20; i++) {
            Random rand = new Random();
            int id= rand.nextInt(10000);
            Product obj=new Product((long) id,"product"+i,i,"detail");
            list.add(obj);
        }
        return list;
    }
 
    @PostConstruct
    public void initJHSAB(){
        log.info("启动AB定时器计划任务淘宝聚划算功能模拟.........."+DateUtil.now());
        new Thread(() -> {
            //模拟定时器，定时把数据库的特价商品，刷新到redis中
            while (true){
                //模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
                List list=this.getProductsFromMysql();
                //先更新B缓存
                this.redisTemplate.delete(JHS_KEY_B);
                this.redisTemplate.opsForList().leftPushAll(JHS_KEY_B,list);
                this.redisTemplate.expire(JHS_KEY_B,20L,TimeUnit.DAYS);
                //再更新A缓存
                this.redisTemplate.delete(JHS_KEY_A);
                this.redisTemplate.opsForList().leftPushAll(JHS_KEY_A,list);
                this.redisTemplate.expire(JHS_KEY_A,15L,TimeUnit.DAYS);
                //间隔一分钟 执行一遍
                try { TimeUnit.MINUTES.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
 
                log.info("runJhs定时刷新双缓存AB两层..............");
            }
        },"t1").start();
    }
}

controller


import com.atguigu.redis7.entities.Product;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
 
@RestController
@Slf4j
@Api(tags = "聚划算商品列表接口")
public class JHSProductController {
    public  static final String JHS_KEY_A="jhs:a";
    public  static final String JHS_KEY_B="jhs:b";
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    @RequestMapping(value = "/pruduct/findab",method = RequestMethod.GET)
    @ApiOperation("防止热点key突然失效，AB双缓存架构")
    public List findAB(int page, int size) {
        List list=null;
        long start = (page - 1) * size;
        long end = start + size - 1;
        try {
            //采用redis list数据结构的lrange命令实现分页查询
            list = this.redisTemplate.opsForList().range(JHS_KEY_A, start, end);
            if (CollectionUtils.isEmpty(list)) {
                log.info("=========A缓存已经失效了，记得人工修补，B缓存自动延续5天");
                //用户先查询缓存A(上面的代码)，如果缓存A查询不到（例如，更新缓存的时候删除了），再查询缓存B
                this.redisTemplate.opsForList().range(JHS_KEY_B, start, end);
                //TODO 走DB查询
            }
            log.info("查询结果：{}", list);
        } catch (Exception ex) {
            //这里的异常，一般是redis瘫痪 ，或 redis网络timeout
            log.error("exception:", ex);
            //TODO 走DB查询
        }
        return list;
    }
}

总结

相关阅读:
Linux常用的一些shell脚本操作记录
 JavaScript获取文件的file对象数据（不通过input）
ECCV 2022 Diffusion models最新研究成果：熵约束算法解决梯度消失问题
 专业级操作，如何快速批量虚化多个视频的背景边框
 windows2012R2 ffmpeg 无法启动此程序，计算机丢失MFPlat.Dll
QT-day1
SpringBoot通过@Cacheable注解实现缓存功能
 【哈士奇赠书活动 - 44期】- 〖从零基础到精通Flutter开发〗
微信小程序+echart实现点亮旅游地图
 整理Meta GDC 2024 上关于XR、空间计算相关的分享
原文地址：https://blog.csdn.net/qq_36942720/article/details/132677397