后端MySQL 与 Redis 前端速成

第十一章:MySQL + Redis 最终面试总复习

你明天就去面前端实习,面试官顺着 Node.js、MySQL、Redis 和你的项目开始拷打。

MySQL 与 Redis 前端速成11 / 11

后端
第十一章:MySQL + Redis 最终面试总复习文章封面

当前1. 索引到底是什么?

这一章我不再按照“教材”讲,而是按照:

你明天就去面前端实习,面试官顺着 Node.js、MySQL、Redis 和你的项目开始拷打。

来整理。

你的简历目前写的是 Node.js(Express)+ 了解 MySQL、Redis,同时项目里有订单状态机、AI 问诊、异步任务、复杂检索等场景,所以你不需要装成 DBA,但一定要做到:核心原理讲得准、项目设计讲得通、追问两三层不会崩。

先给你最终结论:

MySQL 真正必须吃透:索引 + 事务/MVCC/锁 + SQL 优化。

Redis 真正必须吃透:数据类型 + Cache Aside + 三大缓存问题 + 持久化/淘汰 + 分布式锁/幂等。

其他东西都围绕这两条主线展开。


一、先建立最终知识地图

以后面试官问 MySQL,你脑子里应该出现:

MySQL
│
├── 数据怎么查快?
│   └── B+树 → 索引 → 联合索引 → 回表 → 覆盖索引 → EXPLAIN
│
├── 并发修改怎么保证安全?
│   └── 事务 → ACID → 隔离级别 → MVCC → 锁
│
├── SQL 为什么慢?
│   └── 索引 → 扫描量 → 回表 → 排序 → 深分页 → N+1
│
└── 数据为什么不会乱?
    └── 事务 + Undo Log + Redo Log + 锁 + 约束

Redis:

Redis
│
├── 为什么快?
│   └── 内存 + 高效数据结构 + IO多路复用
│
├── 存什么?
│   └── String / Hash / List / Set / ZSet
│
├── 怎么和 MySQL 配合?
│   └── Cache Aside
│
├── 缓存出问题怎么办?
│   └── 穿透 / 击穿 / 雪崩
│
├── 内存满了怎么办?
│   └── TTL + 过期删除 + LRU/LFU
│
├── Redis 重启怎么办?
│   └── RDB / AOF
│
└── 高并发怎么办?
    └── 原子命令 + Lua + 分布式锁 + 幂等 + 限流

如果这两张图能在脑子里建立起来,你已经不会觉得 MySQL、Redis 是一堆散乱八股了。


二、MySQL 第一核心:索引

1. 索引到底是什么?

不要只背:

索引是提高查询效率的数据结构。

你应该回答:

索引本质是用额外的存储空间和写入维护成本,换取查询效率。InnoDB 的索引主要使用 B+ 树,通过有序的数据结构减少需要扫描的数据量。

这里最重要的不是:

“有索引就快。”

而是:

索引的本质是减少扫描。


三、为什么 InnoDB 用 B+ 树?

标准高质量答案:

B+ 树具有较高的扇出,一个节点能够保存很多索引项,因此即使数据量很大,树高通常也比较低,可以减少磁盘页访问次数。同时非叶子节点主要用于索引导航,完整数据集中在叶子节点,叶子节点又按顺序连接,因此既适合等值查询,也非常适合范围查询、排序和顺序扫描。

面试官追问:

为什么不用二叉树?

你回答:

二叉树一个节点最多两个子节点,数据量大时树高容易增加,而数据库一次磁盘 IO 成本远高于内存比较成本,所以数据库更希望用“矮而胖”的树减少 IO 次数。

这就不是只会背“B+树”了。


四、聚簇索引、二级索引、回表

这是必须彻底明白的。

InnoDB:

主键索引
    ↓
B+树叶子节点
    ↓
完整行数据

所以主键索引通常是:

聚簇索引。

普通索引:

name 索引
    ↓
B+树叶子节点
    ↓
name + 主键 id

查询:

-- 根据姓名查询用户完整信息
SELECT *
FROM users
WHERE name = '刘凤伟'; -- name 假设建立了普通索引

过程:

先查询 name 二级索引
       ↓
获得主键 ID
       ↓
再查询主键索引
       ↓
获得完整用户数据

这就是:

回表。


五、覆盖索引

如果:

-- 只查询普通索引本身以及主键字段
SELECT
  id,   -- 主键通常存在于二级索引叶子节点
  name  -- 当前二级索引字段
FROM users
WHERE name = '刘凤伟'; -- 根据 name 索引查询

二级索引已经包含需要的全部字段。

因此:

不需要回表。

这叫覆盖索引。

面试加分点

不要说:

SELECT * 会导致索引失效。

这是错误的。

正确:

SELECT * 不一定导致索引失效,但是容易让查询无法使用覆盖索引,从而增加回表和 IO。


六、联合索引和最左前缀

比如订单查询:

-- 查询某个用户指定状态下的最新订单
SELECT
  id,          -- 订单 ID
  order_no,    -- 订单编号
  created_at   -- 创建时间
FROM orders
WHERE user_id = 1001      -- 第一个等值查询条件
  AND status = 20         -- 第二个等值查询条件
ORDER BY created_at DESC  -- 最后按照时间排序
LIMIT 20;                 -- 只返回最新 20 条

可以设计:

-- 建立用户、状态、创建时间联合索引
CREATE INDEX idx_user_status_created
ON orders (
  user_id,    -- 第一列:用户
  status,     -- 第二列:状态
  created_at  -- 第三列:时间
);

排列逻辑:

先 user_id
    ↓
user_id 相同时按 status
    ↓
前两者相同时按 created_at

所以:

(a,b,c)

a             ✅
a,b           ✅
a,b,c         ✅
b,c           ❌ 无法充分利用最左前缀
a,c           ✅ 可以利用 a,但 c 不能直接跨过 b 完整用于定位

要特别记住:

WHERE 中字段书写顺序不决定联合索引是否生效,优化器可以调整条件。真正重要的是索引自身的字段顺序。


七、索引失效不要背成绝对规则

你应该知道几个高频风险:

对索引列做函数计算

-- 不推荐:对索引列执行函数,可能影响普通索引使用
SELECT
  id,          -- 订单 ID
  created_at   -- 创建时间
FROM orders
WHERE DATE(created_at) = '2026-08-02'; -- 对 created_at 做函数计算

更好:

-- 推荐:直接按照时间范围进行查询
SELECT
  id,          -- 订单 ID
  created_at   -- 创建时间
FROM orders
WHERE created_at >= '2026-08-02 00:00:00' -- 包含当天零点
  AND created_at < '2026-08-03 00:00:00'; -- 不包含第二天零点

前置 %

-- 已知字符串开头,更容易利用普通 B+ 树索引
SELECT
  id,       -- 用户 ID
  name      -- 用户名称
FROM users
WHERE name LIKE '刘%'; -- 前缀确定

而:

-- 前缀未知,普通 B+ 树通常难以快速定位起点
SELECT
  id,       -- 用户 ID
  name      -- 用户名称
FROM users
WHERE name LIKE '%凤伟%'; -- 开头就是通配符

隐式类型转换

数据库是:

phone VARCHAR

查询尽量写:

-- phone 是字符串字段,因此使用字符串进行比较
SELECT
  id,       -- 用户 ID
  phone     -- 手机号
FROM users
WHERE phone = '15118978572'; -- 类型与数据库字段一致

八、MySQL 第二核心:事务

一句话理解:

事务就是一组 SQL,要么一起成功,要么一起失败。

例如:

创建订单
+
扣库存

不能出现:

订单创建成功
库存扣减失败

事务:

-- 开启数据库事务
START TRANSACTION;

-- 创建订单
INSERT INTO orders (
  order_no,   -- 订单编号
  user_id     -- 用户 ID
)
VALUES (
  'ORDER001', -- 新订单编号
  1001        -- 下单用户
);

-- 在库存大于 0 时扣减库存
UPDATE products
SET stock = stock - 1 -- 库存减一
WHERE id = 2001       -- 指定商品
  AND stock > 0;      -- 保证库存不会直接扣成负数

-- 所有操作成功后正式提交
COMMIT;

失败:

-- 事务过程中出现异常时撤销本次修改
ROLLBACK;

九、ACID 必须能脱口而出

A Atomicity     原子性
C Consistency   一致性
I Isolation     隔离性
D Durability    持久性

推荐回答:

原子性保证事务中的操作要么全部成功要么全部失败;一致性保证事务执行前后数据符合业务规则;隔离性处理并发事务之间的相互影响;持久性保证已经提交的数据能够可靠保存。


十、这里补一个前十章没重点讲、但很值得知道的东西

Undo Log 和 Redo Log

Undo Log

主要解决:

后悔怎么办?

执行:

stock:10 → 9

Undo Log 会记录修改前的信息。

作用:

  • 事务回滚;
  • MVCC 历史版本。

记忆:

Undo = 撤销。


Redo Log

主要解决:

已经提交,但服务器突然断电怎么办?

数据库修改通常先操作内存页,如果每个事务都马上随机写磁盘数据页,成本很高。

Redo Log 会记录:

哪些修改已经做过。

宕机恢复时可以根据 Redo Log 恢复已提交事务。

记忆:

Redo = 重做。

非常漂亮的一句回答:

Undo Log 主要保证回滚能力并支持 MVCC,解决“修改了但需要撤销”的问题;Redo Log 记录已经完成的修改,用于崩溃恢复,是事务持久性的重要基础。


十一、binlog 要不要会?

你是前端,不需要深入。

只知道:

binlog 是 MySQL Server 层的逻辑日志,常用于主从复制、数据恢复等。

区别:

Undo Log
回滚 + MVCC

Redo Log
InnoDB 崩溃恢复

Binlog
Server 层归档 / 主从复制 / 数据恢复

这已经够你面前端实习。


十二、隔离级别必须背

从低到高:

Read Uncommitted
读未提交

Read Committed
读已提交

Repeatable Read
可重复读

Serializable
串行化

并发问题:

脏读

读到了别人没有提交的数据。

不可重复读

同一个事务,两次读同一行结果不同。

幻读

相同条件范围查询,前后数据行发生变化。

一句话:

脏读是读了未提交;不可重复读是一行变了;幻读是一批数据变了。


十三、MVCC 是面试里必须讲漂亮的地方

不要只说:

MVCC 就是多版本并发控制。

完整答案:

MVCC 是 InnoDB 用来提高并发读写性能的一套多版本并发控制机制。数据修改时通过 Undo Log 保留历史版本,并结合事务 ID 和 Read View 判断当前事务能够看到哪个版本。这样普通 SELECT 可以读取符合自身可见性规则的历史版本,不需要和写事务互相长时间阻塞。

关键结构:

Undo Log
    +
事务 ID
    +
Read View
    ↓
判断版本可见性

核心价值:

让读和写尽量互不阻塞。


十四、快照读 vs 当前读

普通:

-- 普通 SELECT 一般属于快照读,会根据 MVCC 可见性读取数据
SELECT
  id,      -- 订单 ID
  status   -- 订单状态
FROM orders
WHERE id = 1001; -- 查询指定订单

属于:

快照读。

而:

-- 查询最新数据,同时对目标记录加排他锁
SELECT
  id,      -- 订单 ID
  stock    -- 当前库存
FROM products
WHERE id = 2001 -- 指定商品
FOR UPDATE;     -- 当前读,并加排他锁

属于:

当前读。


十五、MySQL RR 为什么还能处理幻读?

这是进阶加分点。

MySQL InnoDB 默认常见隔离级别是:

Repeatable Read。

它除了使用 MVCC 解决快照读的一致性,在加锁的当前读场景中还会使用:

Record Lock + Gap Lock → Next-Key Lock

简单理解:

Record Lock
锁住已经存在的记录

Gap Lock
锁住记录之间的间隙

Next-Key Lock
记录锁 + 间隙锁

例如查询:

-- 锁定金额处于指定范围的数据,用于演示范围当前读
SELECT
  id,      -- 订单 ID
  amount   -- 订单金额
FROM orders
WHERE amount > 100  -- 查询范围
  AND amount < 200  -- 查询范围
FOR UPDATE;          -- 当前读并加锁

InnoDB 不只是锁已有的记录,还可能锁一定范围的间隙,阻止其他事务往相关范围插入数据,从而降低幻读问题。

你不用深入算法。

面试官问到可以回答:

InnoDB 的 RR 不只是靠 MVCC。快照读主要依赖 MVCC,而当前读还会结合 Record Lock、Gap Lock 和 Next-Key Lock 来限制相关范围的插入,因此能较好处理幻读。

这句话很加分。


十六、乐观锁 vs 悲观锁

悲观锁

我觉得别人一定会和我抢,所以先锁住。

-- 查询商品最新库存,并锁住目标记录
SELECT
  id,     -- 商品 ID
  stock   -- 当前库存
FROM products
WHERE id = 2001 -- 指定商品
FOR UPDATE;     -- 添加排他锁

乐观锁

我先不锁,提交修改时检查版本。

-- 只有版本号仍然为 5 时才允许更新
UPDATE products
SET
  stock = stock - 1,   -- 库存减一
  version = version + 1 -- 更新版本号
WHERE id = 2001        -- 指定商品
  AND stock > 0        -- 保证库存充足
  AND version = 5;     -- 保证数据没有被其他请求修改

一句话:

悲观锁是先锁再改,乐观锁是修改时检测冲突。


十七、真正优秀的库存扣减写法

不要写:

SELECT stock
判断 > 0
UPDATE stock - 1

因为两个请求可能同时读到库存 1。

更好:

-- 只有库存仍然大于零时,数据库才会完成扣减
UPDATE products
SET stock = stock - 1 -- 原子扣减库存
WHERE id = 2001      -- 指定商品
  AND stock > 0;     -- 保证库存不能被扣成负数

然后:

affectedRows = 1
成功

affectedRows = 0
库存不足

这种:

利用数据库条件更新保证原子性

非常值得在面试中说。


十八、MySQL 第三核心:慢 SQL

如果面试官问:

SQL 很慢怎么排查?

别只说:

加索引。

满分思路:

1. 先确定是不是数据库慢
2. 找到具体 SQL
3. EXPLAIN 分析执行计划
4. 看 type
5. 看 key
6. 看 rows
7. 看 Extra
8. 检查索引
9. 检查 SQL 写法
10. 优化后重新测试

标准回答:

我会先判断耗时到底发生在前端渲染、网络、后端业务还是数据库。如果确认 SQL 较慢,再通过慢查询日志找到 SQL,并使用 EXPLAIN 查看 type、实际使用的 key、预计扫描 rows 和 Extra。之后重点检查联合索引设计、回表、函数计算、前置模糊查询、隐式类型转换、额外排序、深分页、N+1 和返回数据量,最后通过实际执行时间验证优化效果。

这段建议背下来。


十九、EXPLAIN 最重要的字段

只背:

type
key
rows
Extra

type 常见:

const
ref
range
index
ALL

越往下通常需要越警惕。

但:

ALL 不是必然有问题。

一张表只有十条数据,全表扫描很合理。

真正危险:

大表
+
高频 SQL
+
ALL
+
rows 巨大

二十、Extra 三兄弟

Using index

通常:

使用了覆盖索引。

Using filesort

需要额外排序。

不代表一定使用磁盘文件。

Using temporary

使用临时表,需要在复杂 GROUP BY / ORDER BY 等场景关注。


二十一、深分页一定会被问

普通:

-- 跳过前十万条,再查询十条
SELECT
  id,          -- 订单 ID
  order_no     -- 订单编号
FROM orders
ORDER BY id DESC -- 按主键倒序
LIMIT 100000, 10; -- 深分页

数据库可能需要:

扫描 100010 条
丢掉前 100000
留下 10 条

游标分页:

-- 根据上一页最后一条记录 ID 查询下一页
SELECT
  id,          -- 订单 ID
  order_no     -- 订单编号
FROM orders
WHERE id < 88888 -- 上一页最后一个 ID
ORDER BY id DESC -- 按 ID 倒序
LIMIT 10;        -- 只获取下一页十条

前端也应该理解:

无限滚动、消息流、订单流适合 cursor / lastId,而后台需要任意跳页时 page/pageSize 更方便。


二十二、N+1 问题

错误:

// 先查询 100 条订单
const orders = await getOrders();

// 遍历 100 条订单
for (const order of orders) {
  // 每条订单都再请求一次数据库查询用户
  order.user = await getUserById(order.userId);
}

数据库:

1 + 100 = 101 次查询

解决:

JOIN / 批量 IN / ORM 预加载。


二十三、SQL 注入——前端转全栈最好会

不要拼字符串:

// 错误示例:直接拼接用户输入,存在 SQL 注入风险
const sql =
  "SELECT * FROM users WHERE username = '" +
  username +
  "'";

应该参数化:

// 使用参数化 SQL,将用户输入与 SQL 结构分离
const [rows] = await pool.execute(
  `
    -- 根据用户名查询用户
    SELECT
      id,        -- 用户 ID
      username   -- 用户名
    FROM users
    WHERE username = ? -- 使用占位符,不直接拼接用户输入
  `,
  [username], // 数据库驱动负责安全处理参数
);

一句话:

用户输入不能直接拼进 SQL,使用参数化查询 / Prepared Statement。


二十四、Redis 第一核心:五种数据类型

最终只需要这样记:

类型一句话典型场景
String一个 Key 一个 ValueToken、验证码、缓存、计数
Hash一个 Key 一个对象用户、任务状态
List有序可重复最近记录、简单队列
Set无序不重复点赞、去重、共同关注
ZSet有 score 的有序集合排行榜、热度

口诀:

String 缓存计数,Hash 保存对象,List 保存队列,Set 负责去重,ZSet 负责排名。

必须背。


二十五、Redis 为什么快?

标准答案:

Redis 的主要数据存放在内存中,避免大量磁盘随机 IO;同时内部数据结构针对不同场景高度优化,命令执行路径相对简单,并采用事件驱动和 IO 多路复用处理大量连接。Redis 核心命令执行主要保持顺序性,减少线程切换和锁竞争,但 Redis 整体并不是所有工作都只有一个线程。

这一段非常值得背。


二十六、Cache Aside 是 Redis 最重要的业务模式

读取:

查 Redis
   ↓
有 → 返回

没有
 ↓
查 MySQL
 ↓
写 Redis
 ↓
返回

写:

更新 MySQL
    ↓
删除 Redis

不是:

更新 MySQL
+
更新 Redis

主要原因:

并发情况下两个请求更新缓存的完成顺序可能与数据库顺序不一致,旧缓存可能覆盖新缓存。

所以:

缓存更适合失效,而不是复杂地同步修改。


二十七、Redis 和 MySQL 一致性标准答案

建议整段背:

在 Cache Aside 模式下,读取时先查 Redis,未命中再查 MySQL 并回填缓存;更新时通常先更新 MySQL,再删除 Redis。这样可以降低并发场景下旧缓存覆盖新数据的风险。不过缓存和数据库很难做到绝对强一致,一般通过合理 TTL、删除失败重试、消息队列补偿等机制保证最终一致性。

非常高频。


二十八、为什么不是“先删 Redis,再更新 MySQL”?

并发场景:

请求 A 删除 Redis
          ↓
请求 B 查询 Redis:没有
          ↓
请求 B 查询 MySQL:旧数据
          ↓
请求 B 将旧数据写 Redis
          ↓
请求 A 更新 MySQL

结果:

MySQL:新
Redis:旧

所以一般:

先更新数据库,再删除缓存。

注意:

也不是绝对不会有问题,只是通常风险窗口更合理。


二十九、Redis 面试必杀三兄弟

必须形成条件反射。

缓存穿透

Redis 没有
MySQL 也没有

请求的是:

不存在的数据。

解决:

参数校验
空值缓存
布隆过滤器
限流

缓存击穿

一个超级热点 Key
突然过期

大量请求:

Redis Miss
    ↓
同时访问 MySQL

解决:

互斥锁
逻辑过期
后台刷新
热点数据预热

缓存雪崩

大量 Key 同时过期
或者
Redis 整体不可用

解决:

随机 TTL
缓存预热
高可用
限流
服务降级

终极口诀:

穿透:查无此人。

击穿:一个明星倒了。

雪崩:整个保安队都倒了。


三十、布隆过滤器必须理解一个坑

不要说:

布隆过滤器可以判断数据是否存在。

准确:

布隆过滤器可以非常确定地判断“某个数据不存在”,但是判断“可能存在”时存在一定误判概率。

所以:

判断不存在
→ 基本可以直接拒绝

判断可能存在
→ 还需要继续查 Redis / MySQL

三十一、Redis 过期 Key 怎么删?

两种核心策略:

惰性删除
+
定期删除

惰性删除

访问时发现已经过期,再删。

定期删除

周期性抽样检查过期 Key。

为什么不是给所有 Key 精确计时?

Key 数量巨大时,为每个 Key 维护精确定时删除成本太高。


三十二、内存满了怎么办?

记住:

过期删除 ≠ 内存淘汰。

过期:

自己寿命到了。

淘汰:

Redis 房间不够了,不得不赶人。

最值得掌握:

LRU

最近最少使用。

记:

看多久没访问。

LFU

最不经常使用。

记:

看访问次数。

面试不要强行说:

LRU 永远最好。

应该:

根据业务访问模式、哪些 Key 可以丢以及热点分布选择策略。


三十三、RDB 和 AOF

口诀:

RDB 拍照片,AOF 写日记。

RDB

定期保存整个数据快照。

优点:

  • 文件紧凑;
  • 恢复快。

缺点:

  • 两次快照之间的数据可能丢失。

AOF

记录写操作。

优点:

  • 数据丢失窗口通常更小。

缺点:

  • 文件更大;
  • 恢复可能更慢;
  • 需要 AOF Rewrite。

标准答案:

RDB 是时间点快照,适合备份和快速恢复,但可能丢失快照间的数据;AOF 持续记录写命令,数据完整性通常更高,但文件更大,需要通过重写控制体积。实际系统可以根据数据重要性结合使用。


三十四、热 Key vs 大 Key

这是高频但很好背。

热 Key

访问次数特别多。

危险:

  • 单节点压力;
  • 网络带宽;
  • 击穿。

解决:

  • 本地缓存;
  • 副本分散;
  • 预热;
  • 不物理过期;
  • 限流。

大 Key

Value 很大或集合元素很多。

危险:

  • 占内存;
  • 网络传输慢;
  • 删除慢;
  • 阻塞;
  • 集群迁移困难。

解决:

  • 拆分;
  • 分页;
  • 避免一次读全部;
  • 大 Key 删除考虑 UNLINK。

口诀:

热 Key 是人太多,大 Key 是东西太重。


三十五、Redis 分布式锁

必须记这一行:

# 只有锁不存在时才能获取,同时设置 10 秒自动过期
SET lock:order:1001 "uuid-abc" NX EX 10

分别:

NX
不存在才能创建

EX
设置过期时间

UUID
确认锁是谁的

三十六、为什么 Value 必须使用唯一 Token?

假设:

A 获得锁
↓
A 超时,锁过期

B 获得新锁
↓
A 执行完
↓
A DEL 锁

A 把 B 的锁删了。

因此:

解锁时必须检查 Redis 中的 Token 是否还是自己的 Token。


三十七、为什么解锁要 Lua?

不能:

GET
判断
DEL

因为两条命令之间锁可能变化。

Lua:

-- 判断当前锁是否仍然属于当前请求
if redis.call('GET', KEYS[1]) == ARGV[1] then
  -- 属于当前请求时才删除锁
  return redis.call('DEL', KEYS[1])
else
  -- 已经不属于当前请求时不能删除
  return 0
end

作用:

判断 + 删除原子执行。


三十八、Redis 锁不是最终保险

这一句非常容易让面试官觉得你不是死背:

对订单、支付、库存这样的核心业务,我不会把 Redis 分布式锁当成唯一一致性保证。Redis 锁主要降低并发冲突,最终仍应该通过 MySQL 唯一索引、条件更新、事务等机制兜底。

例如两名鉴定师抢订单:

-- 只有订单仍然处于待接单状态时才能接单成功
UPDATE orders
SET
  status = 20,         -- 状态修改为进行中
  appraiser_id = 3001  -- 记录鉴定师 ID
WHERE id = 1001        -- 指定订单
  AND status = 10;     -- 必须仍然是待接单状态

谁:

affectedRows = 1

谁成功。

另一个:

affectedRows = 0

失败。

这是比“Redis 加个锁”更可靠的回答。


三十九、幂等一定会用到

定义:

同一个操作执行一次和执行多次,最终结果一致。

例如支付回调。

第三方支付平台可能:

第一次回调
超时没收到你的响应
第二次回调
第三次回调

你不能:

每回调一次
余额 +100

解决:

业务唯一号
+
Redis 幂等 Key
+
数据库唯一索引
+
状态条件

四十、分布式锁和幂等不要混

分布式锁

解决:

能不能同时做?

幂等

解决:

做多次会不会产生多次结果?

一句:

锁解决并发,幂等解决重复。


四十一、Redis 原子性为什么重要?

比如:

# 原子增加接口访问次数
INCR rate_limit:user:1001

Redis 单个命令是原子的。

但:

INCR
+
EXPIRE

是两条命令,就不一定作为整体原子。

可能:

INCR 成功
程序挂了
EXPIRE 没执行

所以多步操作需要:

  • Lua;
  • Redis 事务;
  • 或本身支持组合语义的命令。

面试中重点说:

Lua 可以让多步判断和修改以原子方式在 Redis 内执行。


四十二、Pipeline 和 Lua 的区别——补一个加分点

你不需要深入,但容易被问。

Pipeline

作用主要是:

减少网络往返 RTT。

例如一次批量发 100 个 Redis 命令。

但:

Pipeline 本身不意味着这些命令具有事务原子性。

Lua

主要优势:

多步业务逻辑在 Redis 服务端原子执行。

一句:

Pipeline 解决网络效率,Lua 更侧重多命令原子逻辑。


四十三、Redis 能不能当消息队列?

可以,但要分情况。

List:

# 将任务推入任务列表左侧
LPUSH task:queue "task-1001"

# 从任务列表右侧弹出任务
RPOP task:queue

可以实现简单队列。

但专业系统里:

如果需要消费确认、重试、持久化、消费组、消息追踪等完整能力,一般优先考虑 Redis Stream、RabbitMQ、Kafka 等。

不要说:

List 就是 RabbitMQ。


四十四、结合你的简历:万福鉴酒

你的项目有多角色订单状态流转,这是数据库最好讲的项目之一。

面试官:

订单状态怎么设计?

你可以答:

核心订单数据一定落 MySQL,因为订单需要长期存储、状态流转和事务一致性。Redis 只负责验证码、热点数据、短期幂等 Key 等辅助场景。订单状态更新不能无条件覆盖,而应该通过旧状态条件控制状态机流转。

比如:

-- 只有待接单订单才能进入鉴定中状态
UPDATE orders
SET
  status = 20,       -- 新状态:鉴定中
  updated_at = NOW() -- 更新时间
WHERE id = ?         -- 当前订单 ID
  AND status = 10;   -- 旧状态必须是待接单

然后:

如果影响行数为 0,说明订单已经被其他请求处理,前端重新拉取最新状态。

这就是:

  • 并发控制;
  • 状态机;
  • 轻量乐观锁;
  • 幂等。

四个知识一起讲出来。


四十五、结合生猪健康系统

你的项目存在药品、疾病、文章以及 AI 问诊等读多写少/高频访问数据。

面试官:

哪些数据适合 Redis?

回答:

药品和疾病详情属于典型读多写少数据,可以使用 Cache Aside 缓存;AI 对话长期记录需要 MySQL 持久化,但短期会话上下文、限流计数或者生成状态可以放 Redis。修改药品后先更新 MySQL,再删除对应 Redis Key。

继续追问:

热门药品缓存突然过期?

你:

热点 Key 高并发失效属于缓存击穿,可以通过互斥锁、逻辑过期或者后台刷新解决。

继续:

用户一直请求不存在药品?

你:

属于缓存穿透,可以通过参数校验、短期空值缓存和数据规模较大时使用布隆过滤器。

这一套已经很完整。


四十六、结合 TripStar AI

你的 TripStar 有异步生成进度、结果展示和 AI 对话场景。

非常适合回答:

MySQL + Redis 为什么要一起使用?

你可以回答:

AI 行程生成属于异步长任务。正式用户、任务记录和最终行程需要长期保存,所以落 MySQL;生成中的 progress、status、WebSocket 房间映射等高频临时状态适合 Redis,并设置 TTL。生成完成后最终结果写入 MySQL,临时状态可以删除或自然过期。

继续问:

用户连续点五次生成怎么办?

回答:

前端按钮禁用只是第一层,后端还需要接口幂等。客户端携带幂等 Key,Redis 使用 SET NX EX 快速拦截重复请求,任务表对 request_no 建唯一索引作为最终兜底。

这就是非常好的全栈回答。


四十七、面试官连续拷打模拟 1:MySQL

面试官

MySQL 索引为什么用 B+ 树?

你

B+ 树扇出高、树高低,可以减少磁盘 IO;非叶子节点主要用于索引导航,叶子节点保存数据并且有序连接,所以同时适合等值查询、范围查询和排序。

面试官

什么叫回表?

你

InnoDB 二级索引叶子节点通常保存索引字段和主键,如果查询字段没有完全被二级索引覆盖,就要根据主键再查询聚簇索引获取完整行,这叫回表。

面试官

怎么避免?

你

可以针对高频查询设计覆盖索引,并避免无意义的 SELECT *,但不能为了覆盖索引把大量业务字段全部塞入索引,因为索引本身也有存储和写入维护成本。

这最后一句非常加分。


四十八、面试官连续拷打模拟 2:事务

面试官

MVCC 是什么?

你

MVCC 是多版本并发控制。InnoDB 通过 Undo Log 保存历史版本,通过事务 ID 和 Read View 判断当前事务能够看到哪个版本,使普通查询很多时候不需要和写事务互相阻塞。

面试官

那是不是完全不需要锁?

你

不是。MVCC 主要解决快照读的并发问题,而 UPDATE、DELETE、SELECT FOR UPDATE 等当前读仍然需要锁。

面试官

RR 怎么处理幻读?

你

快照读主要依赖 MVCC,而加锁当前读会结合 Record Lock、Gap Lock 和 Next-Key Lock 对记录和一定范围加锁,从而限制其他事务向相关范围插入数据。

这一套已经明显超过“了解 MySQL”的最低要求。


四十九、面试官连续拷打模拟 3:Redis

面试官

Redis 为什么快?

你

数据主要在内存,高效数据结构,命令执行路径简单,加上事件驱动和 IO 多路复用;核心命令执行主要保持顺序性,也减少了线程切换和锁竞争。

面试官

为什么不能所有东西都放 Redis?

你

Redis 内存成本更高,也不擅长复杂关系查询和完整事务业务。订单、支付、用户、正式行程等核心数据仍应该保存在 MySQL,Redis 更适合作为缓存和临时高频数据存储。

面试官

Redis 持久化以后也不行吗?

你

RDB 和 AOF 提升的是 Redis 的恢复能力,不会改变 Redis 的数据模型和主要定位,所以持久化不等于 Redis 就能替代 MySQL。

很好。


五十、你最容易说错的 12 个地方

这些一定检查一下。

❌ 1. Redis 就是单线程,所以快

应该:

Redis 核心命令执行主要顺序处理,但整体并非所有任务单线程。

❌ 2. SELECT * 会让索引失效

应该:

不一定失效,但可能增加回表、IO 和网络传输。

❌ 3. 使用 OR 一定索引失效

应该:

要结合索引情况和优化器执行计划判断。

❌ 4. type = ALL 一定需要优化

应该:

大表高频查询时要重点关注,小表全表扫描可能更合理。

❌ 5. 建索引一定变快

应该:

优化器根据成本决定是否使用索引。

❌ 6. 索引越多越好

应该:

索引提高查询但增加存储和增删改成本。

❌ 7. Redis 和 MySQL 可以做到绝对一致

应该:

普通缓存系统通常追求最终一致性。

❌ 8. 缓存击穿就是访问不存在的数据

错。

不存在 = 穿透。

❌ 9. Redis 锁可以完全保证订单安全

应该:

数据库唯一约束、状态条件和事务才是重要最终兜底。

❌ 10. RDB 比 AOF 一定好

没有这种绝对结论。

❌ 11. Redis 持久化后可以替代 MySQL

错误。

❌ 12. 分布式锁 = 幂等

错误。

锁防同时执行,幂等防重复结果。


五十一、真正需要你背下来的 15 个问题

如果时间极限,只背这些。

MySQL

1. MySQL 索引为什么使用 B+ 树?

扇出高、树高低、减少 IO,叶子节点有序连接,支持等值、范围和排序。

2. 什么是回表?

二级索引找到主键后,再查询聚簇索引获取完整行数据。

3. 什么是覆盖索引?

查询需要的所有字段都能直接从索引获取,不需要回表。

4. 什么是最左前缀?

联合索引从最左列开始连续匹配才能充分利用索引。

5. 什么是 ACID?

原子性、一致性、隔离性、持久性。

6. 什么是 MVCC?

Undo Log + 事务 ID + Read View 管理数据多个版本,减少读写阻塞。

7. 乐观锁和悲观锁区别?

悲观锁先锁再修改;乐观锁更新时通过 version 或旧状态检查冲突。

8. SQL 慢怎么优化?

定位 SQL → EXPLAIN → type/key/rows/Extra → 索引 → SQL 改写 → 验证。


Redis

9. Redis 为什么快?

内存 + 高效数据结构 + IO 多路复用 + 简单执行模型。

10. 五种类型?

String、Hash、List、Set、ZSet。

11. Redis + MySQL 怎么配合?

Cache Aside:先 Redis,Miss 查 MySQL 回填;写入时先更新 MySQL,再删 Redis。

12. 穿透、击穿、雪崩?

不存在 / 一个热点 / 大量失效。

13. RDB 和 AOF?

快照 vs 写日志。

14. Redis 分布式锁?

SET key token NX EX,Token 唯一,Lua 判断 Token 后删除。

15. 幂等怎么实现?

幂等 Key + Redis 快速拦截 + 数据库唯一索引/状态机最终兜底。


五十二、最后给你一段“我对 MySQL 和 Redis 的理解”

如果面试官直接问:

你对 MySQL 和 Redis 掌握怎么样?

不要回答:

了解一点。

你可以这样说:

我对 MySQL 和 Redis 主要掌握在业务开发和性能设计层面。MySQL 方面,我重点理解 InnoDB 的 B+ 树索引、聚簇索引和二级索引、回表和覆盖索引、联合索引最左前缀,以及事务 ACID、MVCC、隔离级别和乐观锁/悲观锁;遇到查询性能问题会使用 EXPLAIN 分析索引、扫描行数、排序和深分页。

Redis 方面,我主要掌握 String、Hash、List、Set、ZSet 的业务场景,以及 Cache Aside 缓存模式、缓存穿透/击穿/雪崩、TTL 和淘汰策略、RDB/AOF,同时理解用 SET NX EX 和 Lua 实现分布式锁,以及使用 Redis 配合数据库唯一约束实现接口幂等。

对我来说 MySQL 主要负责核心业务数据的可靠持久化和事务一致性,Redis 更多承担缓存、临时状态和高并发辅助能力,两者不是互相替代,而是组合使用。

如果你能自然地讲完这段,面试官再追问:

索引?
→ 能讲

事务?
→ 能讲

MVCC?
→ 能讲

缓存?
→ 能讲

穿透击穿雪崩?
→ 能讲

分布式锁?
→ 能讲

数据一致性?
→ 能讲

对于一个前端实习生,数据库部分已经相当够用了。


五十三、最后的最终压缩版

以后忘记了,回来只看这里。

================ MySQL ================

1. 索引
B+树:矮胖、IO少、支持范围查询

主键索引:
叶子节点保存完整行

二级索引:
叶子节点保存索引值 + 主键

回表:
二级索引 → 主键 → 完整数据

覆盖索引:
数据直接从索引拿,不回表

联合索引:
遵循最左前缀


2. 事务

ACID:
原子、一致、隔离、持久

Undo Log:
回滚 + MVCC

Redo Log:
崩溃恢复

MVCC:
Undo Log + 事务ID + Read View

快照读:
普通 SELECT

当前读:
UPDATE / DELETE / FOR UPDATE


3. 锁

悲观锁:
先锁再改

乐观锁:
version / 旧状态条件

重要业务:
条件更新 + 唯一索引 + 事务兜底


4. SQL 优化

EXPLAIN:
type
key
rows
Extra

重点排查:
索引
SELECT *
函数
前置 %
隐式转换
深分页
N+1
大量返回数据


================ Redis ================

1. 五种类型

String:
缓存、Token、验证码、计数

Hash:
对象

List:
队列、最近记录

Set:
去重、点赞

ZSet:
排行榜


2. Cache Aside

读:
Redis → MySQL → 回填 Redis

写:
更新 MySQL → 删除 Redis


3. 三大缓存问题

穿透:
查询不存在的数据
→ 空值 + 布隆过滤器

击穿:
热点 Key 过期
→ 互斥锁 + 逻辑过期

雪崩:
大量 Key 同时失效
→ 随机 TTL + 预热 + 高可用


4. 内存

过期:
惰性删除 + 定期删除

淘汰:
LRU 看最近使用
LFU 看访问频率


5. 持久化

RDB:
快照

AOF:
写命令日志


6. 高并发

分布式锁:
SET key uuid NX EX 10

释放:
Lua 判断 uuid 后 DEL

幂等:
Redis Key + 唯一索引 + 状态机

核心原则:
Redis 不是最终业务真相
MySQL 才是订单/支付/库存的核心数据源

最后我希望你真正记住的不是 100 个术语,而是这六句话:

索引的本质,是减少扫描。

事务的本质,是保证一组操作的数据正确性。

MVCC 的本质,是让读写尽量不要互相阻塞。

Redis 的本质,是用内存换取高性能。

缓存的本质,是数据库数据的副本,所以允许失效和重建。

Redis 可以挡住大量并发,但核心业务最终一定要让数据库约束、事务和状态机兜底。

你把这六句话真正理解,再把上面的 15 道核心题背下来,你这一天的 MySQL + Redis 学习就已经完成了一个非常有价值的闭环。