clxmm
clxmm
2024-09-24
目录

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

# 1面试题

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

# 2.缓存预热

@PostConstruct初始化白名单数据

# 3.缓存雪崩

# 3.1 是什么

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

# 3.2 预防和解决方案

  • redis中key设置为永不过期 or 过期时间错开
  • redis缓存集群实现高可用
    • 主从+哨兵
    • Redis Cluster
    • 开启Redis持久化机制aof/rdb，尽快恢复缓存集群
  • 多缓存结合预防雪崩
    • ehcache本地缓存 + redis缓存
  • 服务降级
    • Hystrix或者阿里sentinel限流&降级
  • 阿里云-云数据库Redis版

# 4.缓存穿透

# 4.1是什么

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

简单说就是。既不在Redis缓存库，也不在mysql，数据库存在被多次暴击风险

# 4.2解决

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

    • 一般OK

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

      如果发生了缓存穿透，我们可以针对要查询的数据，在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相同的情况

    • but：黑客或者恶意攻击

      • 黑客会对你的系统进行攻击，拿一个不存在的id去查询数据，会产生大量的请求到数据库去查询。可能会导致你的数据库由于压力过大而宕掉
      • key相同打你系统：第一次打到mysql，空对象缓存后第二次就返回defaultNull缺省值，避免mysql被攻击，不用再到数据库中去走一圈了
      • key不同打你系统：由于存在空对象缓存和缓存回写(看自己业务不限死)，redis中的无关紧要的key也会越写越多**(记得设置redis过期时间)**

  • 方案2：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

      • coding

        pom

        <!--guava Google 开源的 Guava 中自带的布隆过滤器-->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.3.0-jre</version>
</dependency>
        1
        2
        3
        4
        5
        6

        test1

        package org.clxmm.bloomfilter;

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;

public class BloomFilterTest1 {


    public static void main(String[] args) {

        // 创建布隆过滤器对象
        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));
    }
}
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23

      • 说明

# 5.缓存击穿

# 5.1 是什么

大量的请求同时查询一个 key 时，此时这个key正好失效了，就会导致大量的请求都打到数据库上面去。

简单说就是热点key突然失效了，暴打mysql

危害

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

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

# 5.2 如何解决

  • 热点key失效

    • 时间到了自然清除但还被访问到
    • delete掉的key，刚巧又被访问

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

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

    多个线程同时去查询数据库的这条数据，那么我们可以在第一个查询数据的请求上使用一个 互斥锁来锁住它。

    其他的线程走到这一步拿不到锁就等着，等第一个线程查询到了数据，然后做缓存。后面的线程进来发现已经有缓存了，就直接走缓存。

# 5.3 案列-天猫聚划算功能实现+防止缓存击穿

问题

问题，热点key突然失效导致了缓存击穿

技术方案实现

  • 分析

    1. 100%先把mysql里面参加活动的数据抽取进redis，一般采用定时器扫描来决定上线活动还是下线取消。
    2. 高并发，绝对不可以用mysql实现
    3. 支持分页功能，一页20条记录

  • redis数据类型

    • list
    • zset

  • coding

    import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Product
{
    //产品ID
    private Long id;
    //产品名称
    private String name;
    //产品价格
    private Integer price;
    //产品详情
    private String detail;
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18

    service

    
import cn.hutool.core.date.DateUtil;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.clxmm.hcjc.entity.Product;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

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<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();
    }

    @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();
    }
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92

    controller

    package org.clxmm.hcjc.controller;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.clxmm.hcjc.entity.Product;
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
@Tag(name = "聚划算商品列表接口")
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)
    @Operation(summary = "按照分页和每页显示容量，点击查看")
    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;
    }

    @RequestMapping(value = "/pruduct/findab", method = RequestMethod.GET)
    @Operation(summary = "防止热点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;
    }
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81

# 6.总结

。

编辑 (opens new window)
#redis
上次更新: 2024/10/10, 21:14:32
14布隆过滤器BloomFilter
redis的分布式锁

← redis的分布式锁→

最近更新
01
vue3
02-08
02
vue3-1
01-24
03
vue3
01-18
更多文章>
Theme by Vdoing | Copyright © 2024-2025 Evan Xu | MIT License