后端MySQL 与 Redis 前端速成

第八章:缓存穿透、缓存击穿、缓存雪崩

这一章是 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

同样会形成巨大的数据库压力。

所以雪崩常见原因有两类:

  1. 大量缓存同时过期;
  2. 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。