第十八章_Redis缓存预热+缓存雪崩+缓存击穿+缓存穿透

缓存预热

缓存预热就是系统启动前，提前将相关的缓存数据直接加载到缓存系统。避免在用户请求的时候，先查询数据库，然后再将数据缓存的问题！用户直接查询事先被预热的缓存数据。

可以通过@PostConstruct初始化白名单数据

缓存雪崩

发生

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

预防+解决

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

缓存穿透

是什么

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

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

解决

一图

方案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源码出处

案例：白名单过滤器

白名单架构说明

误判问题，但是概率小可以接受，不能从布隆过滤器删除

全部合法的key都需要放入Guava版布隆过滤器+redis里面，不然数据就是返回null

Coding实战

建Module

redis7_study

改POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.test.redis7</groupId><artifactId>redis7_study</artifactId><version>1.0-SNAPSHOT</version><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.6.10</version><relativePath/></parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><maven.compiler.source>1.8</maven.compiler.source><maven.compiler.target>1.8</maven.compiler.target><junit.version>4.12</junit.version><log4j.version>1.2.17</log4j.version><lombok.version>1.16.18</lombok.version></properties><dependencies><!--guava Google 开源的 Guava 中自带的布隆过滤器--><dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>23.0</version></dependency><!--SpringBoot通用依赖模块--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--jedis--><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>4.3.1</version></dependency><!--lettuce--><!--<dependency><groupId>io.lettuce</groupId><artifactId>lettuce-core</artifactId><version>6.2.1.RELEASE</version></dependency>--><!--SpringBoot与Redis整合依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId></dependency><!--swagger2--><dependency><groupId>io.springfox</groupId><artifactId>springfox-swagger2</artifactId><version>2.9.2</version></dependency><dependency><groupId>io.springfox</groupId><artifactId>springfox-swagger-ui</artifactId><version>2.9.2</version></dependency><!--Mysql数据库驱动--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version></dependency><!--SpringBoot集成druid连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.10</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.16</version></dependency><!--mybatis和springboot整合--><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>1.3.0</version></dependency><!--hutool--><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.2.3</version></dependency><!--persistence--><dependency><groupId>javax.persistence</groupId><artifactId>persistence-api</artifactId><version>1.0.2</version></dependency><!--通用Mapper--><dependency><groupId>tk.mybatis</groupId><artifactId>mapper</artifactId><version>4.1.5</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-autoconfigure</artifactId></dependency><!--通用基础配置junit/devtools/test/log4j/lombok/--><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>${log4j.version}</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>${lombok.version}</version><optional>true</optional></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

写YML

server.port=7777spring.application.name=redis7_study# ========================logging=====================
logging.level.root=info
logging.level.com.test.redis7=info
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger- %msg%n logging.file.name=D:/mylogs2023/redis7_study.log
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger- %msg%n# ========================swagger=====================
spring.swagger2.enabled=true
#在springboot2.6.X结合swagger2.9.X会提示documentationPluginsBootstrapper空指针异常，
#原因是在springboot2.6.X中将SpringMVC默认路径匹配策略从AntPathMatcher更改为PathPatternParser，
# 导致出错，解决办法是matching-strategy切换回之前ant_path_matcher
spring.mvc.pathmatch.matching-strategy=ant_path_matcher# ========================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# ========================alibaba.druid=====================
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/bigdata?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.druid.test-while-idle=false# ========================mybatis===================
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.test.redis7.entities# ========================redis集群=====================
#spring.redis.password=111111
## 获取失败 最大重定向次数
#spring.redis.cluster.max-redirects=3
#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
##支持集群拓扑动态感应刷新,自适应拓扑刷新是否使用所有可用的更新，默认false关闭
#spring.redis.lettuce.cluster.refresh.adaptive=true
##定时刷新
#spring.redis.lettuce.cluster.refresh.period=2000
#spring.redis.cluster.nodes=192.168.111.185:6381,192.168.111.185:6382,192.168.111.172:6383,192.168.111.172:6384,192.168.111.184:6385,192.168.111.184:6386

主启动

package com.test.redis7;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;/*** @auther admin*/
@SpringBootApplication
@MapperScan("com.test.redis7.mapper")
//import tk.mybatis.spring.annotation.MapperScan;
public class Redis7Study7777 {public static void main(String[] args) {SpringApplication.run(Redis7Study7777.class, args);}}

业务类（取样本100W数据，查查不在100W范围内，其它10W数据是否存在）

Case01

新建测试案例，hello入门

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

Case02

GuavaBloomFilterController

package com.test.redis7.controller;import com.test.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;/*** @auther admin*/
@Slf4j
@RestController
@Api(tags = "google工具Guava处理布隆过滤器")
public class GuavaBloomFilterController {@Resourceprivate GuavaBloomFilterService guavaBloomFilterService;@ApiOperation("guava布隆过滤器插入100万样本数据并额外10W测试是否存在")@RequestMapping(value = "/guavafilter", method = RequestMethod.GET)public void guavaBloomFilter() {guavaBloomFilterService.guavaBloomFilter();}}

GuavaBloomFilterService

package com.test.redis7.service;/*** @auther admin*/
public interface GuavaBloomFilterService{void guavaBloomFilter();}

GuavaBloomFilterServiceImpl

package com.test.redis7.service.impl;import com.test.redis7.service.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 admin*/
@Slf4j
@Service
public class GuavaBloomFilterServiceImpl implements GuavaBloomFilterService {public static final int _1W = 10000;/*** 布隆过滤器里预计要插入多少数据*/public static int size = 100 * _1W;/*** 误判率,它越小误判的个数也就越少(思考，是不是可以设置的无限小，没有误判岂不更好)* 当不设置误判率时，默认的误判率为0.03，当误判率设置的越小，分配的bit数组与使用的hash* 函数个数将会越多，耗费的资源也就越多* 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());}}

上一步结论

现在总共有10万数据是不存在的，误判了3033次，

原始样本：100W

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

可以debug源码分析下，看看hash函数

布隆过滤器说明

黑名单使用

缓存击穿

是什么

大量的请求同时查询一个 key 时，此时这个key正好失效了，就会导致大量的请求都打到数据库上面去。（备注：穿透和击穿，截然不同）

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

危害

会造成某一时刻数据库请求量过大，压力剧增。
一般技术部门需要知道热点key是那些个？做到心里有数防止击穿。

解决

热点key失效

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

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

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

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

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

案例

天猫聚划算功能实现+防止缓存击穿

模拟高并发的天猫聚划算案例code

是什么

生产案例网址

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

技术方案实现

分析过程

步骤	说明
1	100%高并发，绝对不可以用mysql实现
2	先把mysql里面参加活动的数据抽取进redis，一般采用定时器扫描来决定上线活动还是下线取消。
3	支持分页功能，一页20条记录
	请大家思考，redis里面什么样子的数据类型支持上述功能？

高并发+定时任务+分页显示。。。。

redis数据类型选型

springboot+redis实现高并发的聚划算业务V2

建Module

修改上面redis7_study工程

业务类

entity

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

JHSProductController

package com.test.redis7.controller;import com.test.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;/*** @auther admin*/
@Slf4j
@RestController
@Api(tags = "聚划算商品列表接口")
public class JHSProductController {public  static final String JHS_KEY = "jhs";@Autowiredprivate RedisTemplate redisTemplate;/*** 分页查询：在高并发的情况下，只能走redis查询，走db的话必定会把db打垮* @param page 当前页* @param size 页面容量* @return 商品列表*/@ApiOperation("按照分页和每页显示容量，点击查看")@RequestMapping(value = "/pruduct/find", method = RequestMethod.GET)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网络timeoutlog.error("exception:", ex);//TODO 走DB查询}return list;}
}

JHSTaskService

package com.test.redis7.service;import cn.hutool.core.date.DateUtil;
import com.test.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;/*** @auther admin*/
@Slf4j
@Service
public class JHSTaskService {public  static final String JHS_KEY = "jhs";@Autowiredprivate 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;}@PostConstructpublic 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();}
}

备注

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

Bug和隐患说明

热点key突然失效导致可怕的缓存击穿

delete命令执行的一瞬间有空隙，其它请求线程继续找Redis为null

打到了mysql，暴击......

复习again

最终目的

2条命令原子性还是其次，主要是防止热key突然失效暴击mysql打爆系统，^_^。

进一步升级加固案例

复习，互斥跟新，采用双检加锁策略

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

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

差异失效时间

JHSProductController

package com.test.redis7.controller;import com.test.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;/*** @auther admin*/
@Slf4j
@RestController
@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";@Autowiredprivate RedisTemplate redisTemplate;/*** 分页查询：在高并发的情况下，只能走redis查询，走db的话必定会把db打垮* @param page 当前页* @param size 页面容量* @return 商品列表*/@ApiOperation("按照分页和每页显示容量，点击查看")@RequestMapping(value = "/pruduct/find", method = RequestMethod.GET)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网络timeoutlog.error("exception:", ex);//TODO 走DB查询}return list;}/*** 防止热点key突然失效，AB双缓存架构* @param page 当前页* @param size 页面容量* @return 商品列表*/@ApiOperation("防止热点key突然失效，AB双缓存架构")@RequestMapping(value = "/pruduct/findab", method = RequestMethod.GET)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查询不到（例如，更新缓存的时候删除了），再查询缓存Blist = this.redisTemplate.opsForList().range(JHS_KEY_B, start, end);if (CollectionUtils.isEmpty(list)) {//TODO 走DB查询}}log.info("查询结果：{}", list);} catch (Exception ex) {//这里的异常，一般是redis瘫痪 ，或 redis网络timeoutlog.error("exception:", ex);//TODO 走DB查询}return list;}
}

JHSTaskService

package com.test.redis7.service;import cn.hutool.core.date.DateUtil;
import com.test.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;/*** @auther admin*/
@Slf4j
@Service
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;/*** 偷个懒不加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;}//@PostConstructpublic 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);//间隔一分钟 执行一遍try { TimeUnit.MINUTES.sleep(1); } catch (InterruptedException e) { e.printStackTrace();}log.info("runJhs定时刷新..............");}}, "t1").start();}@PostConstructpublic 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();}
}

总结

缓存雪崩

解决方案：

Redis缓存集群实现高可用（合理设置过期时间或者延时，采用哨兵集群等）
采用多级缓存策略，例如 Nginx缓存+Redis缓存+ehcache缓存
采用Hystrix或者阿里sentinel进行服务限流限流或者降级
监控Redis各项指标，即使灾难预警
采用AOF/ RDB持久化，尽快恢复Redis集群

缓存击穿

解决方案：

对于热点key加长过期时间，或者干脆不设置过期时间
二级缓存设置不同的失效时间，保证不会同时失效
如果缓存中没有该key则加锁，保证只会有一个线程打到数据库进行查询（效率较低）

缓存穿透

解决方案：

缓存空对象或者缺省值
- 如果在数据库也无法查询，同样回写到缓存中null值，第二次请求就不会落到数据库中
- 如果黑客恶意攻击每次采取不同的ID那么缓存将越写越多，所以要设置过期时间，并且大量请求还是直接打中了数据库所以该方案有缺陷
使用布隆过滤器

大厂真实需求+面试题

缓存预热、雪崩、穿透、击穿分别是什么？你遇到过那几个情况？

缓存预热你是怎么做的？

如何避免或者减少缓存雪崩？

穿透和击穿有什么区别？他两是一个意思还是截然不同？

穿透和击穿你有什么解决方案？如何避免？

假如出现了缓存不一致，你有哪些修补方案？

。。。。。。

第十八章_Redis缓存预热+缓存雪崩+缓存击穿+缓存穿透相关推荐

【Redis】聊一下缓存雪崩、击穿、穿透、预热
缓存的引入带来了数据读取性能的提升,但是因此也引入新的问题,一个是数据双写一致性,另一个就是雪崩.击穿.穿透,那么如何解决这些问题,我们来说下对应的问题和解决方案雪崩缓存雪崩:同一时间内大量请求无 ...
缓存雪崩、击穿、穿透解决方案
用户的数据一般都是存储于数据库,数据库的数据是落在磁盘上的,磁盘的读写速度可以说是计算机里最慢的硬件了. 当用户的请求,都访问数据库的话,请求数量一上来,数据库很容易就奔溃的了,所以为了避免用户直接访 ...
Redis中的缓存雪崩、击穿、穿透的原因以及解决办法
缓存雪崩.击穿.穿透一旦发生,会导致大量的请求积压到数据库层.如果请求的并发量很大,就会导致数据库宕机或是故障,这就是很严重的生产事故了. 俗话说,知己知彼,百战不殆.了解了问题的成因,我们就能够在应 ...
今天带你们走进缓存的雪崩、击穿、穿透基本概念
在互联网时代,大流量.海量数据.高并发是每个企业都渴望又害怕的名词,渴望是因为它们代表着提供的服务用户愿意买单.有价值;害怕是因为一旦用户全上来了,系统不能正常为用户提供服务,让用户失望,最终选择离开 ...
老司机带你玩转面试（2）：Redis 过期策略以及缓存雪崩、击穿、穿透
前文回顾建议前一篇文章没看过的同学先看下前面的文章: 「老司机带你玩转面试(1):缓存中间件 Redis 基础知识以及数据持久化」过期策略 Redis 的过期策略都有哪些? 在聊这个问题之前,一定 ...
如何解决Redis缓存雪崩、击穿与穿透
Redis最常用使用的场景就是作为业务系统的缓存,既然是作为缓存,那么就不免会碰到缓存常见的问题,即雪崩.击穿与穿透,什么是缓存雪崩.击穿与穿透以及如何解决这几个问题呢?今天我们一起来探讨一下! 一. ...
阿里面试Redis最常问的三个问题：缓存雪崩、击穿、穿透（带答案）
你知道的越多,你不知道的越多点赞再看,养成习惯 https://github.com/java-已经开源,有面试脑图正文上一期吊打系列我们提到了Redis的基础知识,还没看的小伙伴可以回顾一下 ...
缓存的雪崩，击穿，穿透
缓存的雪崩,击穿,穿透前言在将今天的内容之前,我们先来了解一下什么是缓存,缓存是用来干什么的,常用的缓存有哪些? 什么是缓存我们要知道缓存其实就是一个临时的存储器,那么缓存里的数据就不是持久化的 ...
Redis 缓存雪崩、击穿、穿透
Redis 缓存雪崩.击穿.穿透文章目录 Redis 缓存雪崩.击穿.穿透一.Redis基础 Redis基本数据类型.操作二.面试相关问题 1.小伙子您好,看你简历上写了你项目里面用到了Redi ...

第十八章_Redis缓存预热+缓存雪崩+缓存击穿+缓存穿透

第十八章_Redis缓存预热+缓存雪崩+缓存击穿+缓存穿透相关推荐

最新文章

热门文章