当前位置： 首页 > article >正文

Redis高阶6-预热、雪崩、击穿、穿透问题

article 2025/1/28 3:43:05

Redis缓存常见问题

一 缓存预热

1.1 什么是预热

​ 缓存预热是一种在程序启动或缓存失效之后，主动将热点数据加载到缓存中的策略。这样，在实际请求到达程序时，热点数据已经存在于缓存中，从而减少了缓存穿透和缓存击穿的情况，也缓解了SQL服务器的压力。

1.2缓存预热如何解决？

使用 @PostConstruct 初始化白名单数据。

@PostConstruct//初始化白名单数据，
    public void init()
    {
        //白名单客户预加载到布隆过滤器
        String uid = "customer:12";
        //1 计算hashcode，由于可能有负数，直接取绝对值
        int hashValue = Math.abs(uid.hashCode());
        //2 通过hashValue和2的32次方取余后，获得对应的下标坑位
        long index = (long) (hashValue % Math.pow(2, 32));
        System.out.println(uid+" 对应------坑位index:"+index);
        //3 设置redis里面bitmap对应坑位，该有值设置为1
        redisTemplate.opsForValue().setBit("whitelistCustomer",index,true);
    }

二 缓存雪崩

2.1缓存雪崩是什么？

缓存雪崩指的是redis 主机宕机， Redis全盘崩溃，或者redis 中有大量key同时过期大面积失效，导致redis中查不到数据，最终请求到数据库中，对数据库服务器造成压力，导致数据库直接挂了的情况。

2.2发生缓存雪崩的情况

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

2.3 预防和解决

  • redis中key设置为永不过期 or 过期时间错开
  • redis缓存集群实现高可用
  • 多缓存结合预防雪崩
  • 服务降级
  • 云数据库Redis

三 缓存穿透

3.1缓存穿透指的是什么？

​ 请求去查询一条数据，先查询redis，redis中不存在，在去查询mysql，如果mysql里面也是不存在该数据，redis和MySQL都查询不到该条记录，但是这样请求每次都会打到数据库上面去，导致后台数据库压力暴增，这时候redis并没有起到对于MySQL数据库的保护作用，这种现象就称之为缓存穿透。

3.2 如何解决缓存穿透呢？

  • 方案1：空对象缓存或者缺省值

    第一种解决方案，回写增强

    ​ 如果发生了缓存穿透，我们可以针对要查询的数据，在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去查询数据，会产生大量的请求到数据库去查询。可能会导致你的数据库由于压力过大而宕掉

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

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

  • 方案2：Google布隆过滤器Guava解决缓存穿透

https://github.com/google/guava/blob/master/guava/src/com/google/common/hash/BloomFilter.java

案例：白名单过滤器

其它配置见Redis高阶5-布隆过滤器

POM

<!--guava Google 开源的 Guava 中自带的布隆过滤器-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>23.0</version>
        </dependency>

业务类

    @Test
    public void testGuavaWithBloomFilter()
    {
// 创建布隆过滤器对象
        BloomFilter<Integer> 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));
    }

GuavaBloomFilterService

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;

/**
 * @auther zzyy
 * @create 2022-12-30 16:50
 */
@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<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size,fpp);
    public void guavaBloomFilter(){
        //1 先往布隆过滤器里面插入100万的样本数据
        for (int i = 1; i <=size; i++) {
            bloomFilter.put(i);
        }
        //故意取10万个不在过滤器里的值，看看有多少个会被认为在过滤器里
        List<Integer> 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());
    }
}

GuavaBloomFilterController

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
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();
    }
}

四 缓存击穿

4.1 缓存击穿是什么？

​ 缓存击穿就是大量请求同时查询一个key时，此时这个key刚好失效了，就会导致大量的请求到数据库上面去，也就是热点key突然都失效了，MySQL承受高并发量，进而导致数据库宕机

4.2 缓存击穿如何解决？

缓存击穿的解决方式有一下几种：

  1. 差异失效时间，对于访问频繁的热点key，直接就不设置过期时间
  2. 互斥更新，采用双检加锁（多个线程同时去查询数据库的这条数据，那么我们可以在第一个查询数据的请求上使用一个 互斥锁来锁住它。其他的线程走到这一步拿不到锁就等着，等第一个线程查询到了数据，然后做缓存。后面的线程进来发现已经有缓存了，就直接走缓存。）

4.3 案例

以聚划算功能为案例，演示缓存击穿，问题是热点key5突然失效导致了缓存击穿，在通过redis实现聚划算商品推荐之后，每次推荐一组商品，到期后需要更换另一组商品。这时候最危险的就是，到期的商品key删除了，而新的商品key并没有加载到redis中，就会导致缓存击穿。解决思路如下：

  • 功能实现肯定是需要使用 Redis，而不是MySQL实现
  • 先需要将MySQL里面参加活动的数据抽取进Redis，一般采用定时器扫描来决定上线活动还是下线取消。
  • 支持分页功能，一页20条记录
  • 在redis中List数据类型的Lpush即可实现

上述案例的实现还是在之前的功能模块实现：

  1. 业务类

Product

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

JHSTaskService

@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<Product> getProductsFromMysql() {
        List<Product> 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<Product> 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();
    }
}

JHSProductController

@RestController
@Slf4j
@Api(tags = "聚划算商品列表接口")
public class JHSProductController
{
    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;

    /**
     * 分页查询：在高并发的情况下，只能走redis查询，走db的话必定会把db打垮
     * @param page
     * @param size
     * @return
     */
    @RequestMapping(value = "/pruduct/find",method = RequestMethod.GET)
    @ApiOperation("按照分页和每页显示容量，点击查看")
    public List<Product> find(int page, int size) {
        List<Product> 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;
    }
}

启动测试

4.4 Bug和隐患说明

  1. 热点key突然失效，导致缓存击穿

    delete命令执行间隙，其它线程继续找Redis为null

  2. 加强

    1. 互斥更新，采用双检加锁策略

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

      差异失效时间

    请添加图片描述

  3. 代码修改

    JHSTaskService

@PostConstruct
public void initJHSAB(){
    log.info("启动AB定时器计划任务淘宝聚划算功能模拟.........."+DateUtil.now());
    new Thread(() -> {
        //模拟定时器，定时把数据库的特价商品，刷新到redis中
        while (true){
            //模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
            List<Product> 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();
}

JHSProductController

@RequestMapping(value = "/pruduct/findab",method = RequestMethod.GET)
@ApiOperation("防止热点key突然失效，AB双缓存架构")
public List<Product> findAB(int page, int size) {
    List<Product> 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;
}
=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;
}

http://www.kler.cn/a/519345.html

相关文章：

  • 【C语言系列】深入理解指针（4）
  • 基于springboot+vue的古城景区管理系统的设计与实现
  • Three城市引擎地图插件Geo-3d
  • ray.rllib-入门实践-12：自定义policy
  • 矩阵快速幂
  • java读取设置pdf属性信息
  • GoFrame MongoDB 使用指南
  • 【ESP32】ESP-IDF开发 | WiFi开发 | TCP传输控制协议 + TCP服务器和客户端例程
  • svn: E000111: Error running context: Connection refused
  • PCIe 个人理解专栏——【2】LTSSM（Link Training and Status State Machine）
  • 侧边栏布局和响应式布局的对比（Semi Design）
  • 查询本周一到周五的数据
  • STM32的Host U盘
  • vue3 el-form表格滚动
  • 数据库性能优化(sql优化)_SQL执行计划02_yxy
  • Kafka运维宝典 （三）- Kafka 最大连接数超出限制问题、连接超时问题、消费者消费时间超过限制问题详细介绍
  • Redis实战（黑马点评）——关于缓存（缓存更新策略、缓存穿透、缓存雪崩、缓存击穿、Redis工具）
  • AI x 长寿：OpenAI开发出逆龄AI GPT-4b micro
  • LabVIEW进行可靠性测试时有哪些常见的问题
  • 【MFC】C++所有控件随窗口大小全自动等比例缩放源码(控件内字体、列宽等未调整) 20250124
  • [LeetCode] 字符串 I — 344#反转字符串 | 541#反转字符串II | 54K替换数字
  • 如何获取小程序的code在uniapp开发中
  • 系统架构设计师教材：信息系统及信息安全
  • 读后感：《The Clean Coder: A Code of Conduct for Professional Programmers》
  • websocket实现
  • 【DGL系列】dgl中为graph指定CSR/COO/CSC矩阵格式