第八章:缓存穿透、缓存击穿、缓存雪崩
这一章是 Redis 面试最高频章节之一。
MySQL 与 Redis 前端速成8 / 11

这一章是 Redis 面试最高频章节之一。
不要先背定义。我们先把 Redis 想象成万福鉴酒商城门口的一名保安:
- Redis:门口保安,快速回答问题;
- MySQL:后台负责人,查询更可靠,但接待能力有限;
- 用户请求:不停来咨询的顾客。
今天会发生三场事故:
缓存穿透:顾客一直询问根本不存在的商品
缓存击穿:全城都在抢的一件爆款突然失去缓存
缓存雪崩:大量商品缓存在同一时间全部失效
最简单的记忆口诀:
穿透是查不到,击穿是一个热点倒下,雪崩是一大片同时倒下。
一、缓存穿透:Redis 和 MySQL 都查不到
假设正常用户查询药品:
查询药品 5001
↓
Redis 没有
↓
查询 MySQL
↓
MySQL 找到药品
↓
写入 Redis
第一次查询之后,后续请求可以直接命中 Redis。
但是攻击者不断请求:
medicineId = -1
medicineId = 999999999
medicineId = abc
这些药品根本不存在。
每次请求都会这样:
查询 Redis:没有
↓
查询 MySQL:也没有
↓
没有数据可以正常缓存
↓
下一次请求继续查询 MySQL
大量不存在的数据请求,绕过了 Redis,直接打到 MySQL。
这叫:
缓存穿透。
“穿透”就是请求穿过 Redis,持续到达数据库。
二、缓存穿透为什么危险?
正常热门数据只需要第一次查询 MySQL。
但是不存在的数据可能每次都访问 MySQL:
10 万个恶意请求
↓
Redis 全部未命中
↓
MySQL 被查询 10 万次
严重时可能导致:
- MySQL 连接数耗尽;
- CPU 和磁盘 IO 升高;
- 正常接口变慢;
- 数据库被压垮。
三、缓存穿透解决方案一:参数校验
很多明显非法的请求,不应该进入 Redis 和 MySQL。
例如药品 ID 必须是正整数。
// 定义查询药品详情的方法
async function getMedicineDetail(medicineId) {
// 将传入的药品 ID 转换成数字
const normalizedId = Number(medicineId);
// 校验药品 ID 是否为正整数
if (!Number.isInteger(normalizedId) || normalizedId <= 0) {
// 参数非法时直接抛出错误,不查询 Redis 和 MySQL
throw new Error('药品 ID 必须是正整数');
}
// 参数合法后,才继续执行缓存查询逻辑
return queryMedicineWithCache(normalizedId);
}
例如这些请求应该直接拒绝:
/api/medicine/-1
/api/medicine/abc
/api/medicine/null
参数校验只能拦截明显非法的数据。
如果攻击者传入的是合法格式但不存在的 ID:
999999999
仍然可能穿透。
四、解决方案二:缓存空值
数据库查询不到数据时,也在 Redis 中记录一个短期空值。
正常查询代码:
// 定义查询药品详情的方法
async function getMedicineDetail(medicineId) {
// 根据药品 ID 生成缓存 Key
const cacheKey = `medicine:detail:${medicineId}`;
// 优先读取 Redis 缓存
const cachedValue = await redisClient.get(cacheKey);
// Redis 中存在数据时进入判断
if (cachedValue !== null) {
// 特殊字符串 __NULL__ 表示该药品不存在
if (cachedValue === '__NULL__') {
// 直接返回空值,不再查询 MySQL
return null;
}
// 正常缓存转换成 JavaScript 对象后返回
return JSON.parse(cachedValue);
}
// Redis 未命中时查询 MySQL
const [rows] = await pool.execute(
`
-- 根据药品主键查询药品详情
SELECT
id, -- 返回药品 ID
name, -- 返回药品名称
price -- 返回药品价格
FROM medicines
WHERE id = ? -- 根据药品 ID 查询
LIMIT 1 -- 最多返回一条记录
`,
[medicineId], // 安全传入药品 ID
);
// 获取查询结果中的第一条药品记录
const medicine = rows[0];
// MySQL 中也没有查询到药品
if (!medicine) {
// 将空结果缓存一分钟,防止相同无效请求反复访问 MySQL
await redisClient.set(cacheKey, '__NULL__', {
EX: 60, // 空值缓存时间不宜过长
});
// 返回药品不存在
return null;
}
// 将正常药品详情写入 Redis
await redisClient.set(
cacheKey, // 药品详情缓存 Key
JSON.stringify(medicine), // 将药品对象序列化成 JSON
{
EX: 600, // 正常数据缓存十分钟
},
);
// 返回药品详情
return medicine;
}
现在第一次查询不存在的药品:
Redis 没有
↓
MySQL 没有
↓
Redis 缓存一个短期空值
后续请求:
Redis 命中空值
↓
直接返回不存在
↓
不再访问 MySQL
为什么空值缓存时间不能太长?
假设用户查询药品 5001 时,它还没有被创建。
Redis 缓存:
药品 5001 不存在
一分钟后,管理员真的创建了药品 5001。
如果空值缓存设置了一天,用户在一天内仍然看不到新药品。
因此:
空值缓存一般设置较短的过期时间,新增数据后也可以主动删除对应空缓存。
五、解决方案三:布隆过滤器
布隆过滤器可以理解成数据库门口的一张“快速名单”。
它能够快速判断:
一个数据大概率存在,还是一定不存在。
请求来了以后:
请求药品 999999999
↓
先问布隆过滤器
↓
判断一定不存在
↓
直接拒绝,不访问 Redis 和 MySQL
正常流程:
请求
↓
布隆过滤器
↓
可能存在
↓
再查询 Redis
↓
Redis 没有时查询 MySQL
布隆过滤器的特点
判断不存在时,很可靠
布隆过滤器说:
不存在。
那么数据通常确实不存在。
判断存在时,不一定真的存在
布隆过滤器说:
可能存在。
数据库中却可能没有,这叫:
误判,也叫假阳性。
但它不会把实际存在的数据轻易判断成不存在。
一句话记忆:
布隆过滤器说没有,通常真没有;说有,只是可能有。
布隆过滤器为什么会误判?
它不会完整保存所有 ID,而是把数据经过多个哈希计算后,在一组位置上做标记。
不同数据可能碰巧标记了相同位置,所以会出现:
没有加入过的数据
却被判断为可能存在
你不需要掌握底层数学,只要会解释使用场景。
布隆过滤器适合什么场景?
适合:
- 数据量非常大;
- 不存在请求非常多;
- 可以接受少量误判;
- 商品、文章、用户 ID 等存在性判断。
它的缺点:
- 存在误判;
- 删除元素比较麻烦;
- 数据新增时需要同步加入过滤器;
- 增加了系统复杂度。
六、缓存穿透标准答案
必须背:
缓存穿透是指查询一个 Redis 和数据库中都不存在的数据,导致每次请求都绕过缓存访问数据库。可以通过参数校验、缓存短期空值和布隆过滤器解决,同时还可以结合接口限流防止恶意请求。
七、缓存击穿:一个超级热点 Key 突然失效
现在换一个故事。
生猪健康系统有一款超级热门药品:
medicine:detail:5001
平时每秒有 5000 个请求。
缓存存在时:
5000 个请求
↓
全部访问 Redis
↓
MySQL 很轻松
突然,缓存过期了:
medicine:detail:5001 失效
这时 5000 个请求几乎同时发现缓存不存在:
5000 个请求
↓
Redis 全部未命中
↓
5000 个请求一起查询 MySQL
一个热点 Key 失效,瞬间产生大量数据库请求。
这叫:
缓存击穿。
“击穿”可以理解成一个热点位置被大量请求集中打穿。
八、缓存击穿和缓存穿透的区别
缓存穿透
查询的是:
根本不存在的数据。
Redis 没有
MySQL 也没有
缓存击穿
查询的是:
真实存在的热点数据,但缓存刚好过期。
Redis 暂时没有
MySQL 有
一句话记忆:
穿透的数据不存在,击穿的数据存在但缓存掉了。
九、缓存击穿解决方案一:互斥锁
缓存过期以后,不让所有请求同时查询数据库。
只允许一个请求获得锁:
请求 A 获得锁
↓
请求 A 查询 MySQL
↓
请求 A 写入 Redis
↓
请求 A 释放锁
其他请求:
请求 B、C、D 没拿到锁
↓
等待一小段时间
↓
重新查询 Redis
↓
直接读取请求 A 建好的缓存
Node.js 简化示例
// 定义暂停执行的方法
function sleep(milliseconds) {
// 返回一个在指定时间后完成的 Promise
return new Promise((resolve) => {
// 使用定时器实现等待
setTimeout(resolve, milliseconds);
});
}
// 定义带互斥锁的药品详情查询方法
async function getMedicineWithMutex(medicineId) {
// 生成药品缓存 Key
const cacheKey = `medicine:detail:${medicineId}`;
// 生成该药品对应的互斥锁 Key
const lockKey = `lock:medicine:detail:${medicineId}`;
// 第一次查询 Redis 缓存
const cachedMedicine = await redisClient.get(cacheKey);
// 缓存命中时直接返回药品详情
if (cachedMedicine) {
// 将 JSON 字符串转换成药品对象
return JSON.parse(cachedMedicine);
}
// 尝试获取互斥锁,NX 表示只有 Key 不存在时才设置成功
const lockResult = await redisClient.set(
lockKey, // 互斥锁 Key
'locked', // 锁的简单标记值
{
NX: true, // 锁不存在时才能获得锁
EX: 10, // 十秒后自动释放,防止程序异常导致永久死锁
},
);
// 成功获取锁的请求负责查询数据库并重建缓存
if (lockResult === 'OK') {
try {
// 获取锁后再次检查缓存,避免其他请求已经完成重建
const secondCachedValue = await redisClient.get(cacheKey);
// 第二次检查发现缓存已经存在
if (secondCachedValue) {
// 直接返回缓存内容
return JSON.parse(secondCachedValue);
}
// 查询 MySQL 中的真实药品数据
const [rows] = await pool.execute(
`
-- 根据药品 ID 查询药品详情
SELECT
id, -- 返回药品 ID
name, -- 返回药品名称
price -- 返回药品价格
FROM medicines
WHERE id = ? -- 根据药品主键查询
LIMIT 1 -- 最多返回一条数据
`,
[medicineId], // 安全传入药品 ID
);
// 获取查询结果
const medicine = rows[0];
// 数据库中不存在时直接返回空值
if (!medicine) {
return null;
}
// 将数据库结果重新写入 Redis
await redisClient.set(
cacheKey, // 药品详情缓存 Key
JSON.stringify(medicine), // 将药品对象转换成 JSON 字符串
{
EX: 600, // 缓存十分钟
},
);
// 返回最新药品详情
return medicine;
} finally {
// 无论查询是否成功,都尝试释放互斥锁
await redisClient.del(lockKey);
}
}
// 没有获得锁的请求等待五十毫秒
await sleep(50);
// 等待后重新调用查询方法,尝试读取已经建立的缓存
return getMedicineWithMutex(medicineId);
}
这段代码让你理解思想即可,实际生产代码还要处理:
- 锁只能由持有者释放;
- 等待次数上限;
- 请求超时;
- Redis 异常;
- 数据库异常;
- 防止无限递归。
这些会在第十章分布式锁中详细讲。
十、为什么获得锁后要再次查询缓存?
执行过程可能是:
请求 A:第一次查缓存,没有
请求 B:第一次查缓存,没有
请求 A:获得锁
请求 A:重建缓存并释放锁
请求 B:随后获得锁
如果请求 B 获得锁后直接查询 MySQL,就会重复重建缓存。
所以请求 B 获得锁后要再查一次 Redis:
获得锁
↓
再次检查缓存
↓
缓存已经存在
↓
直接返回
这叫:
双重检查。
十一、缓存击穿解决方案二:热点数据不过期
对于极其热门的数据,可以不设置普通物理过期时间。
例如:
# 保存热门药品详情,不设置 Redis 自动过期时间
SET medicine:detail:5001 "{\"id\":5001,\"name\":\"热门药品\"}"
后台定时任务主动更新缓存。
优点:
- 热点 Key 不会突然消失;
- 不会因为自然过期瞬间冲击数据库。
缺点:
- 需要主动更新;
- 更新失败时可能长期保留旧数据;
- 需要额外的缓存维护机制。
十二、逻辑过期是什么?
不让 Redis 自动删除 Key,而是在 Value 中保存一个业务过期时间。
JavaScript 数据结构可以是:
// 定义带逻辑过期时间的缓存对象
const cacheData = {
data: {
// 保存真实的药品数据
id: 5001,
// 保存药品名称
name: '阿莫西林',
},
// 保存业务层面的逻辑过期时间
expireAt: Date.now() + 10 * 60 * 1000,
};
查询时:
Redis Key 始终存在
↓
检查 expireAt
↓
没有过期:直接返回
已经过期:仍可暂时返回旧数据,同时异步更新缓存
这样用户不必等待数据库查询。
这是一种:
用短暂旧数据换取系统稳定性的方案。
适合可以容忍短暂不一致的热门内容,例如:
- 热门文章;
- 热门榜单;
- 商品展示信息;
- 推荐数据。
不适合:
- 支付结果;
- 实时库存;
- 退款状态;
- 强一致性数据。
十三、缓存击穿标准答案
必须背:
缓存击穿是指某个访问量极高的热点 Key 突然过期,大量并发请求同时绕过 Redis 访问数据库。可以使用互斥锁,只允许一个请求重建缓存;也可以对热点数据设置逻辑过期或通过后台任务提前更新缓存。
十四、缓存雪崩:大量 Key 同时失效
现在发生第三场事故。
开发人员给十万个药品缓存都设置了:
每天凌晨 00:00 统一过期
到了凌晨:
十万个缓存同时失效
↓
大量请求同时访问 MySQL
↓
数据库负载突然暴涨
这叫:
缓存雪崩。
就像山上的一大片雪同时滑下来,不是一个 Key 出问题,而是一批 Key 一起出问题。
十五、Redis 服务宕机也可能造成雪崩
缓存雪崩不仅是大量 Key 同时过期。
Redis 整体不可用时:
Redis 宕机
↓
所有缓存都无法读取
↓
请求全部访问 MySQL
同样会形成巨大的数据库压力。
所以雪崩常见原因有两类:
- 大量缓存同时过期;
- Redis 服务整体故障。
十六、击穿和雪崩的区别
缓存击穿
重点是:
一个超级热点 Key 失效。
一个重点目标
被大量请求集中攻击
缓存雪崩
重点是:
大量 Key 同时失效,或者 Redis 整体不可用。
大量缓存一起倒下
记忆:
击穿是一点爆炸,雪崩是一片坍塌。
十七、缓存雪崩解决方案一:随机过期时间
不要让大量 Key 在同一时刻失效。
例如基础过期时间十分钟,再增加零到五分钟随机值。
// 设置缓存基础过期时间为十分钟
const baseExpireSeconds = 600;
// 生成零到三百秒之间的随机值
const randomExpireSeconds = Math.floor(Math.random() * 300);
// 计算当前缓存的最终过期时间
const finalExpireSeconds = baseExpireSeconds + randomExpireSeconds;
// 将药品详情写入 Redis
await redisClient.set(
`medicine:detail:${medicineId}`, // 药品详情缓存 Key
JSON.stringify(medicine), // 将药品对象转换成 JSON 字符串
{
EX: finalExpireSeconds, // 使用随机过期时间,避免缓存集中失效
},
);
最终缓存过期时间会分散在:
10 分钟
11 分钟
12 分钟
13 分钟
14 分钟
15 分钟
不会同时失效。
十八、解决方案二:缓存预热
系统上线或大型活动开始前,提前把热点数据写入 Redis。
例如万福鉴酒准备活动:
活动开始前
↓
提前查询热门酒品
↓
写入 Redis
↓
活动开始时直接命中缓存
Node.js 简化示例:
// 定义热门药品缓存预热方法
async function warmUpHotMedicines() {
// 从 MySQL 中查询最近访问量最高的药品
const [medicines] = await pool.execute(
`
-- 查询热度最高的前一百种药品
SELECT
id, -- 返回药品 ID
name, -- 返回药品名称
price -- 返回药品价格
FROM medicines
ORDER BY view_count DESC -- 按照访问量从高到低排序
LIMIT 100 -- 只查询前一百种药品
`,
);
// 遍历所有热门药品
for (const medicine of medicines) {
// 为不同药品生成不同的随机过期时间
const expireSeconds = 1800 + Math.floor(Math.random() * 600);
// 提前写入 Redis 缓存
await redisClient.set(
`medicine:detail:${medicine.id}`, // 药品详情缓存 Key
JSON.stringify(medicine), // 将药品对象转换成 JSON
{
EX: expireSeconds, // 设置分散的过期时间
},
);
}
}
缓存预热适合:
- 系统启动;
- 秒杀活动;
- 热门榜单;
- 大促活动;
- 可预测的流量高峰。
十九、解决方案三:限流和降级
即使 Redis 出现故障,也不能让无限请求全部进入 MySQL。
限流
限制单位时间内的请求数量。
例如:
每个用户每秒最多请求 5 次
整个接口每秒最多处理 1000 次
超过限制的请求:
直接拒绝
或者稍后重试
降级
系统压力过高时,暂时关闭非核心功能。
例如生猪健康系统:
核心功能:
药品查询
疾病查询
AI 问诊
非核心功能:
热门排行榜
相关推荐
浏览记录
复杂统计
系统压力过高时,可以暂时不展示:
- 推荐列表;
- 热门榜单;
- 非关键统计;
- 个性化内容。
但要保住:
- 登录;
- 支付; -订单;
- 核心查询。
一句话:
降级不是系统坏了,而是主动放弃次要功能,保护核心业务。
二十、解决方案四:Redis 高可用
如果 Redis 只有一台服务器:
这一台 Redis 宕机
↓
全部缓存不可用
企业项目会考虑:
- 主从复制;
- Sentinel 哨兵;
- Redis Cluster 集群;
- 故障自动切换;
- 多节点部署。
你现在只需要理解:
高可用的目标是避免单个 Redis 节点故障导致整个缓存服务不可用。
具体的主从复制和集群原理会在第九章简单讲。
二十一、解决方案五:本地缓存作为临时兜底
后端服务有时会在应用内存中保存极少量热点数据。
例如 Node.js 进程内使用 Map:
// 创建一个简单的本地内存缓存
const localCache = new Map();
// 将系统配置放入本地缓存
localCache.set(
'system:config', // 本地缓存 Key
{
// 保存系统名称
systemName: '生猪健康管理系统',
// 保存系统维护状态
maintenance: false,
},
);
Redis 故障时,可以短暂返回本地缓存中的数据。
但本地缓存有明显限制:
- 不同服务器之间数据不共享;
- 服务重启后数据消失;
- 容易产生数据不一致;
- 不能无限存储。
所以只适合:
- 少量系统配置;
- 极少量热点只读数据;
- 短期应急兜底。
二十二、缓存雪崩标准答案
必须背:
缓存雪崩是指大量缓存 Key 在同一时间过期,或者 Redis 服务整体不可用,导致大量请求同时访问数据库。可以通过设置随机过期时间、缓存预热、热点数据提前刷新、限流降级以及 Redis 高可用部署来降低风险。
二十三、三大问题放在一起比较
| 问题 | 数据是否存在 | 核心原因 | 主要方案 |
|---|---|---|---|
| 缓存穿透 | Redis、MySQL 都不存在 | 反复查询不存在的数据 | 参数校验、空值缓存、布隆过滤器 |
| 缓存击穿 | MySQL 存在 | 单个热点 Key 突然过期 | 互斥锁、逻辑过期、热点提前刷新 |
| 缓存雪崩 | 数据通常存在 | 大量 Key 同时失效或 Redis 宕机 | 随机 TTL、预热、高可用、限流降级 |
最重要的三句话:
穿透:查不存在的数据。
击穿:一个热点 Key 失效。
雪崩:大量 Key 一起失效。
二十四、故事记忆法
缓存穿透:查无此人
有人每天来学校问:
99999 号学生在哪?
学校根本没有这个人。
保安名单没有,教务处也没有,但他每次都要求查教务系统。
解决:
- 检查学号格式;
- 记录“此人不存在”;
- 提前建立学生名单过滤器。
缓存击穿:明星来了
学校最火的学生资料缓存突然失效。
一万个人同时问教务处:
他的信息是什么?
解决:
- 只派一个人去教务处查询;
- 其他人等待结果;
- 或提前更新明星资料。
缓存雪崩:保安集体下班
所有保安同时下班,所有人一起冲进教务处。
解决:
- 保安错峰下班;
- 安排替班人员;
- 限制进入人数;
- 保留应急方案。
二十五、结合你的三个项目
以下是项目设计思路,未实际实现时应说“如果让我设计”。
1. 生猪健康系统:药品详情缓存
面试官问:
大量用户恶意请求不存在的药品 ID 怎么办?
你可以回答:
我会先校验 ID 格式,对数据库中不存在的药品缓存一个短时间空值。如果数据规模和攻击量较大,可以在缓存前增加布隆过滤器,快速拦截一定不存在的药品 ID,并结合接口限流降低恶意流量。
2. 万福鉴酒:热门商品缓存
面试官问:
大促期间热门酒品缓存突然过期怎么办?
你可以回答:
这是典型的缓存击穿。我会对热点 Key 使用互斥锁,只允许一个请求查询 MySQL 并重建缓存,其他请求短暂等待后重新读取 Redis。也可以使用逻辑过期和后台异步刷新,避免热点 Key 物理消失。
3. TripStar AI:大量任务缓存同时过期
面试官问:
AI 任务状态都设置一小时过期,会不会有风险?
你可以回答:
如果大量任务在同一时刻创建,并设置完全相同的 TTL,就可能在同一时刻集中失效。可以在基础 TTL 上加入随机时间,使过期时间分散。对于仍在执行的任务,还需要在状态更新时续期,最终结果落入 MySQL。
二十六、一个综合查询流程
一个相对完整的药品查询流程可以这样设计:
请求进入
↓
参数是否合法?
├─ 否:直接拒绝
↓
布隆过滤器判断是否可能存在
├─ 一定不存在:直接返回
↓
查询 Redis
├─ 命中正常数据:直接返回
├─ 命中空值:直接返回不存在
↓
尝试获得互斥锁
├─ 获得锁:查询 MySQL,重建缓存
└─ 未获得锁:短暂等待,再查缓存
不是每个小项目都必须全部实现。
系统设计必须考虑复杂度:
- 普通后台:参数校验 + 空值缓存已经够用;
- 大流量平台:可以增加布隆过滤器;
- 超级热点接口:再考虑互斥锁或逻辑过期。
不要为了面试,把所有技术都硬塞进项目。
二十七、本章必须背的四段答案
1. 什么是缓存穿透?
缓存穿透是查询 Redis 和数据库中都不存在的数据,导致每次请求都访问数据库。可以通过参数校验、缓存空值、布隆过滤器和接口限流解决。
2. 什么是缓存击穿?
缓存击穿是某个高并发热点 Key 突然过期,大量请求同时访问数据库。可以通过互斥锁、逻辑过期或后台提前刷新热点缓存解决。
3. 什么是缓存雪崩?
缓存雪崩是大量 Key 同时过期,或者 Redis 服务整体不可用,导致大量请求集中访问数据库。可以通过随机过期时间、缓存预热、限流降级和 Redis 高可用解决。
4. 三者最核心的区别是什么?
缓存穿透针对不存在的数据;缓存击穿针对单个失效的热点 Key;缓存雪崩针对大量 Key 同时失效或整个 Redis 服务故障。
二十八、一分钟背诵卡
穿透
数据不存在
方案:校验、空值、布隆过滤器
击穿
一个热点 Key 过期
方案:互斥锁、逻辑过期、提前刷新
雪崩
大量 Key 同时过期或 Redis 宕机
方案:随机 TTL、预热、高可用、限流降级
二十九、本章闯关题
第 1 题
用户不断查询数据库中不存在的商品,这是什么?
答案:
缓存穿透。
第 2 题
一件超级热门商品的缓存突然过期,一万个请求同时访问 MySQL,这是什么?
答案:
缓存击穿。
第 3 题
每天凌晨十二点,大量缓存同时过期,这是什么?
答案:
缓存雪崩。
第 4 题
缓存不存在的数据有什么作用?
答案:
避免相同的无效请求反复访问 MySQL,但空值的过期时间一般不宜过长。
第 5 题
布隆过滤器说数据不存在,意味着什么?
答案:
数据通常确实不存在;如果它说可能存在,数据不一定真的存在,因为布隆过滤器存在误判。
第 6 题
解决击穿时,为什么只有一个请求可以查询 MySQL?
答案:
让一个请求负责重建缓存,避免大量并发请求同时访问数据库,其他请求等待后读取新缓存。
第 7 题
随机 TTL 主要解决什么问题?
答案:
避免大量缓存集中在同一时刻失效,降低缓存雪崩风险。
下一章学习 Redis 为什么快、Key 如何过期、内存满了怎么办、RDB 和 AOF 如何持久化,以及大 Key、热 Key 为什么会拖垮 Redis。