缓存预热
缓存预热就是系统启动前,提前将相关的缓存数据直接加载到缓存系统。避免在用户请求的时候,先查询数据库,然后再将数据缓存的问题!用户直接查询事先被预热的缓存数据。
可以通过@PostConstruct初始化白名单数据
缓存雪崩
发生
预防+解决
缓存穿透
是什么
请求去查询一条记录,先查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
4.0.0
com.test.redis7
redis7_study
1.0-SNAPSHOT
org.springframework.boot
spring-boot-starter-parent
2.6.10
UTF-8
1.8
1.8
4.12
1.2.17
1.16.18
com.google.guava
guava
23.0
org.springframework.boot
spring-boot-starter-web
redis.clients
jedis
4.3.1
org.springframework.boot
spring-boot-starter-data-redis
org.apache.commons
commons-pool2
io.springfox
springfox-swagger2
2.9.2
io.springfox
springfox-swagger-ui
2.9.2
mysql
mysql-connector-java
5.1.47
com.alibaba
druid-spring-boot-starter
1.1.10
com.alibaba
druid
1.1.16
org.mybatis.spring.boot
mybatis-spring-boot-starter
1.3.0
cn.hutool
hutool-all
5.2.3
javax.persistence
persistence-api
1.0.2
tk.mybatis
mapper
4.1.5
org.springframework.boot
spring-boot-autoconfigure
junit
junit
${junit.version}
org.springframework.boot
spring-boot-starter-test
test
log4j
log4j
${log4j.version}
org.projectlombok
lombok
${lombok.version}
true
org.springframework.boot
spring-boot-maven-plugin
写YML
server.port=7777
spring.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 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 {
@Resource
private 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 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
不存在数据:1000001W---1100000W
可以debug源码分析下,看看hash函数
布隆过滤器说明
黑名单使用
缓存击穿
是什么
大量的请求同时查询一个 key 时,此时这个key正好失效了,就会导致大量的请求都打到数据库上面去。(备注:穿透和击穿,截然不同)
简单说就是热点key突然失效了,暴打mysql。
危害
解决
热点key失效
方案1:差异失效时间,对于访问频繁的热点key,干脆就不设置过期时间
方案2:互斥跟新,采用双检加锁策略
多个线程同时去查询数据库的这条数据,那么我们可以在第一个查询数据的请求上使用一个 互斥锁来锁住它。
其他的线程走到这一步拿不到锁就等着,等第一个线程查询到了数据,然后做缓存。后面的线程进来发现已经有缓存了,就直接走缓存。
案例
天猫聚划算功能实现+防止缓存击穿
模拟高并发的天猫聚划算案例code
是什么
生产案例网址
问题,热点key突然失效导致了缓存击穿。
技术方案实现
分析过程
建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";
@Autowired
private RedisTemplate redisTemplate;
/**
* 分页查询:在高并发的情况下,只能走redis查询,走db的话必定会把db打垮
* @param page 当前页
* @param size 页面容量
* @return 商品列表
*/
@ApiOperation("按照分页和每页显示容量,点击查看")
@RequestMapping(value = "/pruduct/find", method = RequestMethod.GET)
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;
}
}
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";
@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();
}
}
备注
至此步骤,上述聚划算的功能算是完成,请思考在高并发下有什么经典生产问题?
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";
@Autowired
private RedisTemplate redisTemplate;
/**
* 分页查询:在高并发的情况下,只能走redis查询,走db的话必定会把db打垮
* @param page 当前页
* @param size 页面容量
* @return 商品列表
*/
@ApiOperation("按照分页和每页显示容量,点击查看")
@RequestMapping(value = "/pruduct/find", method = RequestMethod.GET)
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;
}
/**
* 防止热点key突然失效,AB双缓存架构
* @param page 当前页
* @param size 页面容量
* @return 商品列表
*/
@ApiOperation("防止热点key突然失效,AB双缓存架构")
@RequestMapping(value = "/pruduct/findab", method = RequestMethod.GET)
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
list = this.redisTemplate.opsForList().range(JHS_KEY_B, 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;
}
}
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";
@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);
//间隔一分钟 执行一遍
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 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();
}
}
总结
缓存雪崩
解决方案:
缓存击穿
解决方案:
缓存穿透
解决方案:
大厂真实需求+面试题
缓存预热、雪崩、穿透、击穿分别是什么?你遇到过那几个情况?
缓存预热你是怎么做的?
如何避免或者减少缓存雪崩?
穿透和击穿有什么区别?他两是一个意思还是截然不同?
穿透和击穿你有什么解决方案?如何避免?
假如出现了缓存不一致,你有哪些修补方案?
。。。。。。