下面给你一个 Spring Boot 整合 Redis 的完整步骤，并且给出一个可运行的例子（含配置 + 操作代码 + 测试接口）。我会以 Spring Boot 3.x + Redis + Lettuce 为默认组合（目前主流），如果你用的是 Boot 2.x 也能照着改。

---

✅ 一、准备环境

1）安装并启动 Redis

• 本机安装 Redis 或 Docker 启动 Redis：

bash
docker run -d --name redis -p 6379:6379 redis:7

验证：

bash
redis-cli ping
# PONG

---

✅ 二、Spring Boot 项目引入依赖

Maven pom.xml

xml
<dependencies>
    <!-- Spring Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <!-- Web (写接口演示用) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- lombok 可选 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

Spring Boot 默认使用 Lettuce 客户端（推荐），无需额外依赖。

---

✅ 三、配置 Redis 连接

application.yml

yaml
spring:
  data:
    redis:
      host: localhost
      port: 6379
      database: 0
      timeout: 5s

      lettuce:
        pool:
          max-active: 8
          max-idle: 8
          min-idle: 0
          max-wait: 1s

如果 Redis 需要密码，加上：

yaml
spring:
  data:
    redis:
      password: yourpassword

---

✅ 四、配置 RedisTemplate（推荐写）

默认 RedisTemplate key/value 序列化是 JDK 序列化，读起来是乱码，所以一般会自定义：

RedisConfig.java

java
package com.example.demo.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // key 使用 String 序列化
        StringRedisSerializer keySerializer = new StringRedisSerializer();

        // value 使用 JSON 序列化
        GenericJackson2JsonRedisSerializer valueSerializer =
                new GenericJackson2JsonRedisSerializer(new ObjectMapper());

        template.setKeySerializer(keySerializer);
        template.setHashKeySerializer(keySerializer);

        template.setValueSerializer(valueSerializer);
        template.setHashValueSerializer(valueSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

---

✅ 五、写一个 Redis 操作 Service（例子）

RedisService.java

java
package com.example.demo.service;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.time.Duration;

@Service
public class RedisService {

    private final RedisTemplate<String, Object> redisTemplate;

    public RedisService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // set
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    // set with ttl
    public void set(String key, Object value, long seconds) {
        redisTemplate.opsForValue().set(key, value, Duration.ofSeconds(seconds));
    }

    // get
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    // delete
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }
}

---

✅ 六、写一个 Controller 提供测试接口（可直接访问）

RedisController.java

java
package com.example.demo.controller;

import com.example.demo.service.RedisService;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/redis")
public class RedisController {

    private final RedisService redisService;

    public RedisController(RedisService redisService) {
        this.redisService = redisService;
    }

    // http://localhost:8080/redis/set?key=name&value=aaron
    @GetMapping("/set")
    public String set(@RequestParam String key, @RequestParam String value) {
        redisService.set(key, value);
        return "OK";
    }

    // http://localhost:8080/redis/get?key=name
    @GetMapping("/get")
    public Object get(@RequestParam String key) {
        return redisService.get(key);
    }

    // http://localhost:8080/redis/setex?key=name&value=aaron&seconds=10
    @GetMapping("/setex")
    public String setEx(@RequestParam String key,
                        @RequestParam String value,
                        @RequestParam long seconds) {
        redisService.set(key, value, seconds);
        return "OK, TTL=" + seconds + "s";
    }

    // http://localhost:8080/redis/del?key=name
    @GetMapping("/del")
    public String del(@RequestParam String key) {
        return redisService.delete(key) ? "Deleted" : "Not Found";
    }
}

---

✅ 七、测试（访问接口）

1. 设置值：

GET http://localhost:8080/redis/set?key=name&value=aaron

2. 获取值：

GET http://localhost:8080/redis/get?key=name

3. 设置带过期时间：

GET http://localhost:8080/redis/setex?key=name&value=aaron&seconds=10

4. 删除：

GET http://localhost:8080/redis/del?key=name

---

⭐ 进阶：缓存注解方式（@Cacheable）

如果你想写成“自动缓存”：

1）开启缓存

java
@SpringBootApplication
@EnableCaching
public class DemoApplication { ... }

2）配置 CacheManager（可选）

Spring Boot 默认 RedisCacheManager 可以直接用（只要你引了 Redis starter）

3）使用缓存注解

java
@Cacheable(cacheNames = "user", key = "#id")
public User getUserById(Long id){
    return userMapper.selectById(id);
}

---

✅ 总结：整合 Redis 关键步骤

✅ 1. 启动 Redis
✅ 2. 引入 spring-boot-starter-data-redis
✅ 3. 配置 application.yml
✅ 4. 自定义 RedisTemplate 序列化
✅ 5. 使用 RedisTemplate / StringRedisTemplate 操作 Redis
✅ 6.（可选）使用 Spring Cache 注解

---

如果你愿意，我可以继续给你：

• ✅ 一个完整 CRUD 的 User 缓存例子（MySQL + Redis）
• ✅ Redis 分布式锁实现（基于 Redisson / Lua）
• ✅ 实现登录验证码、Session、限流等经典场景 你想要哪种？

下面把 Redis 常用操作给你系统性地整理一份，按数据类型 + 场景来讲，同时给出 命令行 + Spring Boot（RedisTemplate） 两种用法，基本覆盖 80% 日常开发。

---

一、String（最常用 ⭐⭐⭐⭐⭐）

典型场景

• 缓存对象 / JSON
• 验证码
• 分布式锁
• 计数器

---

常用命令

bash
SET key value
GET key
DEL key
EXISTS key
EXPIRE key 60
TTL key

原子操作

bash
INCR count
INCRBY count 10
DECR count

设置过期时间

bash
SETEX code:1234 60 8888

---

Spring Boot 示例

java
// 设置
redisTemplate.opsForValue().set("name", "tom");

// 设置并过期
redisTemplate.opsForValue().set("code", "8888", 60, TimeUnit.SECONDS);

// 获取
String name = (String) redisTemplate.opsForValue().get("name");

// 自增
redisTemplate.opsForValue().increment("count", 1);

---

二、Hash（对象缓存 ⭐⭐⭐⭐⭐）

典型场景

• 用户信息
• 商品信息
• 部分字段更新

---

常用命令

bash
HSET user:1 name tom age 18
HGET user:1 name
HGETALL user:1
HDEL user:1 age
HEXISTS user:1 name

---

Spring Boot 示例

java
redisTemplate.opsForHash().put("user:1", "name", "tom");
redisTemplate.opsForHash().put("user:1", "age", 18);

Object name = redisTemplate.opsForHash().get("user:1", "name");

Map<Object, Object> user =
        redisTemplate.opsForHash().entries("user:1");

---

三、List（队列 / 消息 ⭐⭐⭐⭐）

典型场景

• 消息队列
• 异步任务
• 最新记录列表

---

常用命令

bash
LPUSH list a b c
RPUSH list 1 2 3
LPOP list
RPOP list
LRANGE list 0 -1

阻塞队列

bash
BLPOP queue 10
BRPOP queue 10

---

Spring Boot 示例

java
redisTemplate.opsForList().leftPush("queue", "msg1");
redisTemplate.opsForList().rightPush("queue", "msg2");

Object msg = redisTemplate.opsForList().leftPop("queue");

List<Object> list =
        redisTemplate.opsForList().range("queue", 0, -1);

---

四、Set（去重集合 ⭐⭐⭐⭐）

典型场景

• 点赞 / 关注
• 抽奖
• 去重统计

---

常用命令

bash
SADD likes 1 2 3
SMEMBERS likes
SISMEMBER likes 1
SREM likes 2
SCARD likes

随机取值

bash
SRANDMEMBER likes
SPOP likes

---

Spring Boot 示例

java
redisTemplate.opsForSet().add("likes", 1, 2, 3);
Boolean liked =
        redisTemplate.opsForSet().isMember("likes", 1);
Long size =
        redisTemplate.opsForSet().size("likes");

---

五、ZSet（排行榜 ⭐⭐⭐⭐⭐）

典型场景

• 积分榜
• 排行榜
• 延时队列

---

常用命令

bash
ZADD rank 100 tom
ZADD rank 90 jack
ZRANGE rank 0 -1 WITHSCORES
ZREVRANGE rank 0 9 WITHSCORES
ZSCORE rank tom

删除

bash
ZREM rank tom

---

Spring Boot 示例

java
redisTemplate.opsForZSet().add("rank", "tom", 100);
redisTemplate.opsForZSet().add("rank", "jack", 90);

Set<Object> top10 =
        redisTemplate.opsForZSet().reverseRange("rank", 0, 9);

---

六、Key 通用操作（必会 ⭐⭐⭐⭐⭐）

bash
KEYS user:*
SCAN 0 MATCH user:* COUNT 100
TYPE key

⚠️ 生产环境慎用 KEYS，用 SCAN

---

Spring Boot

java
Boolean exists = redisTemplate.hasKey("name");
redisTemplate.delete("name");
redisTemplate.expire("name", 60, TimeUnit.SECONDS);

---

七、分布式锁（高频面试 ⭐⭐⭐⭐⭐）

原理

bash
SET lock:order 1 NX EX 10

Spring 示例

java
Boolean lock = redisTemplate.opsForValue()
        .setIfAbsent("lock:order", "1", 10, TimeUnit.SECONDS);

if (Boolean.TRUE.equals(lock)) {
    try {
        // 业务逻辑
    } finally {
        redisTemplate.delete("lock:order");
    }
}

⚠️ 生产建议用 Redisson

---

八、Redis 经典应用场景速查表

场景	数据结构
缓存对象	String / Hash
验证码	String
分布式锁	String
点赞 / 收藏	Set
排行榜	ZSet
消息队列	List
延时任务	ZSet

---

九、面试高频问题（重点）

Q1：为什么 Redis 快？

• 内存操作
• 单线程 + IO 多路复用
• 高效数据结构

Q2：Redis 过期策略？

• 定期删除
• 惰性删除

Q3：Redis 淘汰策略？

• LRU / LFU / TTL

---

✅ 总结（记住这 10 个就够了）

• SET / GET
• HSET / HGET
• LPUSH / LPOP
• SADD / SISMEMBER
• ZADD / ZREVRANGE
• EXPIRE / TTL
• INCR
• SETNX
• SCAN
• DEL

---

如果你需要，我可以下一步给你：

• ✅ Redis 面试 30 问速记版
• ✅ 高并发缓存设计（穿透 / 击穿 / 雪崩）
• ✅ Redis + Lua 脚本实战
• ✅ Redis 在真实项目中的设计规范

你更想看哪一个？

下面我用**“真实业务场景”来讲清楚：在 Spring Boot 项目里，Redis 不是“为了用而用”，而是用来解决性能、并发、分布式一致性**等问题。你只要掌握下面 6 类业务用法，基本覆盖 80% 项目需求。

我会给你每个场景的 业务逻辑 → Redis 设计 → Spring Boot 代码示例（可直接用）。

---

✅ 场景 1：查询缓存（最常见：查数据库太慢）

业务需求

查询商品详情时，数据库压力大 → 用 Redis 缓存提升性能

Redis 设计

• key：product:{id}
• value：JSON（或者对象序列化）
• TTL：比如 30 分钟

代码示例（Service层）

java
@Service
public class ProductService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private ProductMapper productMapper;

    public Product getProduct(Long id) {
        String key = "product:" + id;

        // 1. 先查缓存
        Product cache = (Product) redisTemplate.opsForValue().get(key);
        if (cache != null) return cache;

        // 2. 查数据库
        Product db = productMapper.selectById(id);
        if (db == null) return null;

        // 3. 写入缓存（设置过期）
        redisTemplate.opsForValue().set(key, db, 30, TimeUnit.MINUTES);
        return db;
    }
}

✅ 这就是最标准的缓存旁路模式（Cache Aside）

---

✅ 场景 2：验证码 / 短信登录（强一致 + 过期）

业务需求

手机验证码 60 秒过期，且只能用一次

Redis 设计

• key：sms:code:{phone}
• value：验证码
• TTL：60 秒

代码示例

java
public void sendCode(String phone) {
    String code = String.valueOf((int)(Math.random() * 9000 + 1000));
    redisTemplate.opsForValue().set("sms:code:" + phone, code, 60, TimeUnit.SECONDS);
    // 调用短信服务发送 code ...
}

public boolean login(String phone, String inputCode) {
    String key = "sms:code:" + phone;
    String realCode = (String) redisTemplate.opsForValue().get(key);

    if (realCode == null) return false;
    if (!realCode.equals(inputCode)) return false;

    // ✅ 防止重复使用：登录成功立即删除
    redisTemplate.delete(key);
    return true;
}

---

✅ 场景 3：计数器（点赞、阅读量、库存预扣）

业务需求

文章阅读量、点赞数高频更新，不适合每次写数据库

Redis 设计

• key：article:view:{id}
• INCR 自增（原子性）

代码示例

java
public Long addView(Long articleId) {
    String key = "article:view:" + articleId;
    return redisTemplate.opsForValue().increment(key, 1);
}

💡 常见做法：Redis 先累计，定时任务每隔 1 分钟刷回数据库。

---

✅ 场景 4：防刷限流（接口保护、短信防刷）

业务需求

一个 IP 1 分钟内最多访问 60 次，否则封禁

Redis 设计

• key：limit:{ip}
• value：访问次数
• TTL：60 秒
• 超过阈值拦截

代码示例

java
public boolean limit(String ip) {
    String key = "limit:" + ip;
    Long count = redisTemplate.opsForValue().increment(key, 1);

    if (count == 1) {
        redisTemplate.expire(key, 60, TimeUnit.SECONDS);
    }
    return count <= 60;
}

✅ 这个就是滑动窗口简化版，实际更严谨可以用 Lua。

---

✅ 场景 5：分布式锁（防止超卖、重复下单）

业务需求

同一订单只能处理一次（防止并发重复提交）

Redis 设计

• key：lock:order:{orderId}
• SETNX + EX 作为锁

代码示例（简单版）

java
public void pay(Long orderId) {
    String lockKey = "lock:order:" + orderId;

    Boolean lock = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);

    if (!Boolean.TRUE.equals(lock)) {
        throw new RuntimeException("请勿重复提交");
    }

    try {
        // 执行业务：扣库存、支付
    } finally {
        redisTemplate.delete(lockKey);
    }
}

⚠️ 生产环境建议用 Redisson，支持可重入、自动续期。

---

✅ 场景 6：购物车（Hash 很适合）

业务需求

购物车：同一用户对商品增删改查非常频繁

Redis 设计（推荐）

• key：cart:{userId}
• hash field：商品id
• hash value：数量

代码示例

java
public void addToCart(Long userId, Long productId, int num) {
    String key = "cart:" + userId;
    redisTemplate.opsForHash().increment(key, productId.toString(), num);
}

public Map<Object, Object> getCart(Long userId) {
    return redisTemplate.opsForHash().entries("cart:" + userId);
}

public void deleteItem(Long userId, Long productId) {
    redisTemplate.opsForHash().delete("cart:" + userId, productId.toString());
}

---

✅ 场景 7（加分）：缓存穿透 / 击穿 / 雪崩（真实项目必遇）

1）缓存穿透（查不到的数据一直查 DB）

✅ 解决：缓存空值

java
if (db == null) {
    redisTemplate.opsForValue().set(key, "NULL", 2, TimeUnit.MINUTES);
    return null;
}

2）缓存击穿（热点 key 过期瞬间并发打 DB）

✅ 解决：加互斥锁（Redis 分布式锁）

3）缓存雪崩（大量 key 同时过期）

✅ 解决：TTL 随机化

java
int ttl = 30 * 60 + new Random().nextInt(300); // 30分钟 + 0~5分钟随机
redisTemplate.opsForValue().set(key, db, ttl, TimeUnit.SECONDS);

---

✅ 最佳实践（你写业务时按这个套路来）

你在 Service 层写业务逻辑，一般长这样：

✅ 模板：查缓存 → 查 DB → 写缓存

java
public Object query(Long id) {
    String key = "xxx:" + id;
    Object cache = redisTemplate.opsForValue().get(key);
    if (cache != null) return cache;

    Object db = mapper.selectById(id);
    if (db == null) return null;

    redisTemplate.opsForValue().set(key, db, 30, TimeUnit.MINUTES);
    return db;
}

---

✅ 总结：Redis 在 SpringBoot 业务里到底怎么用？

业务需求	Redis 用法
查询加速	String / Hash 缓存
登录验证码	String + TTL
点赞/阅读量	INCR 原子计数
限流防刷	INCR + EXPIRE
防重复提交	分布式锁
购物车	Hash

---

如果你愿意，我可以再给你一个完整可运行的业务 Demo（包含 Controller + Service + Redis + MySQL 模拟），比如：

✅ 商品详情缓存（含缓存穿透/击穿解决方案）
✅ 订单支付防重复提交（分布式锁）
✅ 秒杀防超卖（预扣库存 + Lua 脚本）

你更想看哪一个业务场景？我可以直接给你一整套代码。

下面把「Redis 集群」给你讲清楚：它到底是什么、怎么搭、怎么在 Spring Boot 里用、以及和哨兵/主从的区别。尽量用工程视角讲，照着就能落地。

---

1）Redis 集群到底是什么

Redis 集群（Redis Cluster）是 Redis 官方提供的分片（sharding）+ 高可用方案：

• 数据分片：把 key 分布到多个节点上（水平扩展），提升容量/吞吐
• 高可用：每个主节点配从节点，主挂了从自动提升为主
• 槽（slot）机制：一共 16384 个槽，每个 key 会被 hash 到某个槽，槽归属某个主节点

你可以理解成：

“多个主节点共同存数据（分片），每个主节点后面有从节点保命（HA）”。

---

2）Cluster vs Sentinel vs 主从（怎么选）

主从复制（Master-Slave）

• ✅ 读写分离、简单
• ❌ 不分片，容量上不去；故障切换要自己做或靠哨兵

哨兵（Sentinel）

• ✅ 高可用：自动故障切换（主从架构上加哨兵）
• ❌ 不分片，容量仍上不去

集群（Cluster）

• ✅ 分片 + 高可用，可横向扩展
• ❌ 业务要注意：多 key 操作/事务/ Lua 可能受限（下面会讲）

选型口诀：

• 只是要 HA：选 Sentinel
• 要扩容/大数据量/高吞吐：选 Cluster

---

3）Redis Cluster 的关键限制（业务必须知道）

A. 多 key 操作必须在同一个 slot

比如这些命令会受影响：

• MGET k1 k2
• SUNION set1 set2
• 事务里操作多个 key
• Lua 脚本操作多个 key

如果 key 不在同一个 slot，就会报类似：

CROSSSLOT Keys in request don't hash to the same slot

✅ 解决办法：Hash Tag（强制同槽）
用 {} 包住相同部分：

• order:{1001}:info
• order:{1001}:items
• order:{1001}:pay

这样 {1001} 相同，保证在同一个 slot，就能多 key 一起玩。

B. Cluster 不能用 SELECT 切库

Cluster 模式下 SELECT 1/2/3 基本不可用（只用 db0）。

---

4）本地快速搭一个 Redis Cluster（6 节点示例）

典型：3 主 3 从。开发测试很常用。

方式一：Docker（推荐）

你可以直接用现成的 compose（思路如下）：

• 起 6 个 redis 容器：7001-7006
• 开启 cluster 配置（cluster-enabled yes）
• 执行创建集群命令，把 3 主 3 从配起来

创建命令大致类似：

bash
redis-cli --cluster create \
  127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 \
  127.0.0.1:7004 127.0.0.1:7005 127.0.0.1:7006 \
  --cluster-replicas 1

验证集群

bash
redis-cli -p 7001 cluster nodes
redis-cli -p 7001 cluster info

如果你需要我给你一份可直接跑的 docker-compose.yml（6 节点 + 自动创建集群脚本），我也可以直接贴完整版本。

---

5）Spring Boot 连接 Redis Cluster（最常用）

依赖（不变）

xml
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

application.yml（Cluster）

yaml
spring:
  data:
    redis:
      timeout: 5s
      cluster:
        nodes:
          - 127.0.0.1:7001
          - 127.0.0.1:7002
          - 127.0.0.1:7003
      lettuce:
        pool:
          max-active: 8
          max-idle: 8
          min-idle: 0

✅ 这就够了。Spring Data Redis 会自动识别 cluster，并处理 MOVED/ASK 重定向。

如果有密码：

yaml
spring:
  data:
    redis:
      password: yourpassword

业务层照常用 RedisTemplate

Cluster 下你的业务代码基本不变：

java
redisTemplate.opsForValue().set("product:1", "xxx");
Object v = redisTemplate.opsForValue().get("product:1");

---

6）Cluster 下写业务要注意什么（落地经验）

① 设计 key 时考虑同槽（Hash Tag）

如果你有需要“一次操作多个 key”的场景（事务、Lua、批量），提前设计：

• cart:{userId}（一个用户的购物车）
• order:{orderId}:*（一个订单的多个维度）

② 分布式锁建议用 Redisson

Cluster 下自己写 SET NX EX 也能用，但工程上更稳的是 Redisson（看门狗续期、可重入、公平锁等）。

③ Pipeline / 批量操作要小心

Pipeline 在 cluster 下如果 key 分散到不同节点，客户端会拆分执行；收益不一定像单机那么大，但仍可用。

---

7）你最可能遇到的 3 个问题

1. CROSSSLOT 报错
   → 用 {} hash tag 保证同槽

2. 性能瓶颈还在
   → 先确认是否热 key（某些 key 集中在一个 slot/节点），需要拆 key 或加二级缓存/本地缓存

3. 扩容怎么做
   → 加新主节点，然后做 reshard（迁槽）。线上要规划好窗口与监控

---

如果你告诉我你现在的目标是：

• ✅ 只是要高可用（主挂自动切）
• ✅ 还是要扩容（数据量/吞吐上不去）
• ✅ 以及你大概的业务（缓存、购物车、排行榜、秒杀、锁）

我可以直接给你：

1. 一套可运行的 Docker Redis Cluster 6 节点配置
2. 对应的 Spring Boot 工程示例
3. 以及 key 设计（含 hash tag） 的最佳实践模板。

这是一个非常经典、也是面试和实战都会深挖的问题 👍
我按 「是什么 → 怎么用 → 区别 → 关系 → 常见坑」 给你讲清楚 Spring 事务 vs MySQL 事务，看完你就知道：

👉 Spring 事务不是另一种事务，它本质上是对数据库事务的“管理层封装”

---

一、先一句话结论（先立结论）

MySQL 事务是“底层能力”
Spring 事务是“应用层管理与控制方式”

• MySQL 事务：真正执行 BEGIN / COMMIT / ROLLBACK
• Spring 事务：决定什么时候开启、提交、回滚数据库事务

---

二、MySQL 事务（数据库层）

1️⃣ MySQL 事务是什么

MySQL（准确说是 InnoDB）提供的事务，保证 ACID：

特性	含义
A	原子性
C	一致性
I	隔离性
D	持久性

---

2️⃣ MySQL 事务怎么用

显式事务

sql
START TRANSACTION;
UPDATE account SET money = money - 100 WHERE id = 1;
UPDATE account SET money = money + 100 WHERE id = 2;
COMMIT;
-- 或 ROLLBACK;

自动事务（默认）

sql
-- 每条 SQL 都是一个事务
UPDATE account SET money = money - 100 WHERE id = 1;

---

3️⃣ MySQL 事务核心点

✔ 隔离级别（重点）

sql
SELECT @@transaction_isolation;

隔离级别	问题
READ UNCOMMITTED	脏读
READ COMMITTED	不可重复读
REPEATABLE READ（默认）	幻读（通过 MVCC 基本解决）
SERIALIZABLE	性能差

---

三、Spring 事务（应用层）

1️⃣ Spring 事务是什么

Spring 事务是 对数据库事务的统一抽象和管理：

• 统一事务 API
• 支持多种事务实现（JDBC / JPA / MyBatis）
• 支持 声明式事务（@Transactional）

👉 Spring 自己不存数据，不做事务提交，它只是：

在方法前：开启事务
在方法成功结束：提交事务
在方法异常：回滚事务

---

2️⃣ Spring 事务最常见用法

java
@Service
public class OrderService {

    @Transactional
    public void createOrder() {
        // 1. 操作数据库
        // 2. 如果这里抛异常 → Spring 决定 rollback
    }
}

底层等价于（伪代码）：

java
beginTransaction();
try {
    business();
    commit();
} catch (Exception e) {
    rollback();
}

---

四、Spring 事务 vs MySQL 事务（核心区别）

维度	Spring 事务	MySQL 事务
层级	应用层	数据库层
本质	管理事务	执行事务
是否真实提交	❌	✅
控制方式	@Transactional	SQL
是否依赖数据库	✅	❌（数据库自身能力）
可管理范围	方法级	SQL 级

👉 Spring 事务最终一定会落到 MySQL 事务上

---

五、两者是如何协作的（重点理解）

一次完整流程

java
@Transactional
public void transfer() {
    dao.updateA();
    dao.updateB();
}

实际发生的事：

1. Spring 拦截方法（AOP）
2. Spring 从连接池拿一个 Connection
3. conn.setAutoCommit(false)
4. 执行 SQL（MySQL InnoDB 事务生效）
5. 方法成功 → conn.commit()
6. 方法异常 → conn.rollback()

👉 MySQL 不知道 Spring 的存在
👉 Spring 只是“指挥” MySQL

---

六、事务生效的 5 个前提（高频坑）

1️⃣ 必须是 public 方法

java
@Transactional
private void test() {} // ❌ 不生效

2️⃣ 必须通过 Spring 代理调用

java
this.method(); // ❌ 事务失效

3️⃣ 默认只回滚 RuntimeException

java
@Transactional
public void test() throws Exception {
    throw new Exception(); // ❌ 不回滚
}

正确写法：

java
@Transactional(rollbackFor = Exception.class)

---

4️⃣ 数据库引擎必须支持事务

sql
SHOW TABLE STATUS;
-- InnoDB ✅
-- MyISAM ❌

---

5️⃣ 事务传播行为影响很大（重点）

java
@Transactional(propagation = Propagation.REQUIRED)

传播行为	含义
REQUIRED	有事务就加入，没有就新建（默认）
REQUIRES_NEW	新开事务，挂起外层
NESTED	嵌套事务（基于 savepoint）

---

七、Spring 事务 ≠ 分布式事务（非常重要）

❌ 错误理解

Spring 事务可以管理多个数据库

✅ 正确认知

• Spring 默认事务是 本地事务
• 一个事务只能绑定一个数据库连接

---

分布式事务要用：

• Seata
• XA
• TCC
• 最终一致性（MQ）

---

八、经典面试题速答版

Q1：Spring 事务失效的原因？

• 非 public
• 自调用
• 异常被 catch 掉
• 非 RuntimeException
• 非 InnoDB

---

Q2：@Transactional 和 MySQL 隔离级别谁说了算？

• MySQL 决定实际隔离
• Spring 只是“声明期望值”

---

Q3：Spring 事务一定安全吗？

❌ 不一定

• 并发问题要靠 锁 / 隔离级别
• 超卖问题靠 行锁 / 乐观锁

---

九、一句话总结（你可以背）

MySQL 事务负责“数据正确性”
Spring 事务负责“什么时候开始、什么时候结束”

如果你愿意，我可以下一步直接给你画清楚：

• 🔥 事务传播行为调用链示意图
• 🔥 Spring 事务失效的真实案例
• 🔥 @Transactional 底层源码流程
• 🔥 和 Redis、消息队列一起用时的事务问题

你更想深入哪一个？

下面我给你一份 「MySQL 面试必备基础知识点总结」，这是我按高频面试题 + 实际项目必用整理的版本。
你把这一份吃透，初中级 MySQL 面试基本稳了，高级也能答 70%。

我会按 “必须会 → 理解即可 → 常被追问” 的层级来讲，方便你复习。

---

一、MySQL 基础（必须 100% 会）

1️⃣ MySQL 架构 & 存储引擎

常见存储引擎

引擎	是否支持事务	是否支持行锁	场景
InnoDB（默认）	✅	✅	OLTP、核心业务
MyISAM	❌	❌（表锁）	只读、历史数据

面试必答：

• 为什么 InnoDB 是默认？
  • 支持事务
  • 行级锁
  • 崩溃恢复（redo log）

---

2️⃣ 事务（必考 ⭐⭐⭐⭐⭐）

ACID

• 原子性（Atomicity）
• 一致性（Consistency）
• 隔离性（Isolation）
• 持久性（Durability）

---

隔离级别（高频）

隔离级别	脏读	不可重复读	幻读
READ UNCOMMITTED	✅	✅	✅
READ COMMITTED	❌	✅	✅
REPEATABLE READ（默认）	❌	❌	⚠️
SERIALIZABLE	❌	❌	❌

追问点：

• InnoDB 如何解决幻读？
  👉 MVCC + 间隙锁（Next-Key Lock）

---

3️⃣ MVCC（必会原理）

核心概念

• Read View
• undo log
• 版本链

作用

• 实现 非阻塞读
• 提高并发性能

面试一句话：

MVCC 通过 undo log 保存历史版本，读操作不加锁，写操作加行锁。

---

4️⃣ 锁机制（高频）

锁分类

• 行锁（InnoDB）
• 表锁
• 间隙锁
• 临键锁（Next-Key Lock）

两种锁

• 共享锁（S）
• 排他锁（X）

面试常问：

• 为什么会死锁？
  • 事务加锁顺序不一致
• 如何避免？
  • 统一加锁顺序
  • 减少事务范围

---

二、索引（面试重灾区 ⭐⭐⭐⭐⭐）

5️⃣ 索引是什么 & 为什么快

• 本质：B+Tree
• 作用：减少磁盘 IO
• InnoDB：聚簇索引

---

6️⃣ B+Tree 索引结构（必会）

为什么用 B+Tree？

• 高度低（3～4 层可存千万数据）
• 范围查询快
• 叶子节点有序、双向链表

❌ Hash 索引不适合范围查询

---

7️⃣ 聚簇索引 & 二级索引

类型	存什么
聚簇索引	主键 + 行数据
二级索引	索引字段 + 主键

回表是什么？

通过二级索引查到主键，再回到聚簇索引查整行数据。

---

8️⃣ 索引失效场景（必背）

• where 中对索引列 使用函数
• 隐式类型转换
• 头部模糊查询：like '%abc'
• or 左右未全部命中索引
• 不符合最左前缀原则

---

9️⃣ 最左前缀原则（高频）

sql
index(a, b, c)

可用：

• a
• a, b
• a, b, c

不可用：

• b
• c

---

三、SQL & 执行流程（常考）

🔟 SQL 执行顺序（必考）

text
FROM
JOIN
WHERE
GROUP BY
HAVING
SELECT
ORDER BY
LIMIT

---

1️⃣1️⃣ explain（优化必会）

重点字段

• type（性能从好到差）
  system > const > eq_ref > ref > range > index > ALL
• key（是否走索引）
• rows（扫描行数）

面试目标：

• 尽量避免 ALL
• rows 越小越好

---

四、日志系统（理解即可，但常被问）

1️⃣2️⃣ 三大日志

日志	作用
undo log	回滚 / MVCC
redo log	崩溃恢复
binlog	主从复制

redo vs binlog

• redo：InnoDB 特有，物理日志
• binlog：MySQL Server 层，逻辑日志

---

1️⃣3️⃣ 两阶段提交（高频）

为什么要两阶段提交？
👉 保证 redo log 和 binlog 一致性，避免主从不一致。

---

五、主从 & 高可用（中级必备）

1️⃣4️⃣ 主从复制原理

1. 主库写 binlog
2. 从库 IO 线程拉 binlog
3. 从库 SQL 线程重放

---

1️⃣5️⃣ 主从延迟原因

• 从库单线程执行
• 大事务
• 网络延迟

---

六、性能与设计（加分项）

1️⃣6️⃣ 表设计原则

• 合理字段类型（int > varchar）
• 避免过多 NULL
• 控制表宽
• 冷热数据分离

---

1️⃣7️⃣ 常见性能问题

• 慢 SQL
• 索引设计不合理
• 大事务
• 热点行

---

七、面试速记版（直接背）

• InnoDB 默认引擎，支持事务和行锁
• 默认隔离级别 RR，通过 MVCC + Next-Key Lock 防幻读
• 索引是 B+Tree，主键是聚簇索引
• 二级索引需要回表
• explain 看 type 和 rows
• redo log 保证崩溃恢复，binlog 保证复制
• 两阶段提交保证日志一致性

---

八、面试官最爱追问 TOP 5

1. 索引为什么用 B+Tree 而不用 BTree / Hash？
2. RR 是如何解决幻读的？
3. 回表是什么？怎么避免？
4. 事务为什么会失效？
5. 慢 SQL 怎么定位和优化？

---

如果你愿意，我可以下一步帮你做更狠的：

🔥 MySQL 面试 50 问（标准答案版）
🔥 MySQL 高频 SQL 题（含索引分析）
🔥 InnoDB 底层原理深挖（配图讲）
🔥 真实面试追问 + 反问模板

你打算面 校招 / 社招 1–3 年 / 3–5 年？我可以直接按目标岗位给你定制一套 MySQL 面试清单。

下面给你一份 《MySQL 面试 50 问（标准答案版）》，这是面试官真实高频 + 标准可背答案整理的版本。
我按 基础 → 索引 → 事务 → 日志 → 锁 → 主从 → 优化 分组，你可以 直接背，也适合临面突击。

---

一、基础原理（1–8）

1️⃣ MySQL 常用存储引擎有哪些？默认是哪个？

答：

• 常用：InnoDB、MyISAM
• 默认：InnoDB
• 原因：支持事务、行锁、崩溃恢复

---

2️⃣ InnoDB 和 MyISAM 的区别？

答：

• InnoDB：支持事务、行锁、外键
• MyISAM：不支持事务、表锁、性能高但不安全

---

3️⃣ 什么是数据库事务？

答： 事务是一组操作的逻辑单元，要么全部成功，要么全部失败。

---

4️⃣ 事务的 ACID 是什么？

答：

• A 原子性
• C 一致性
• I 隔离性
• D 持久性

---

5️⃣ MySQL 默认隔离级别？

答：

• REPEATABLE READ（可重复读）

---

6️⃣ 各隔离级别解决了什么问题？

答：

隔离级别	脏读	不可重复读	幻读
RU	❌	❌	❌
RC	✅	❌	❌
RR	✅	✅	⚠️
SERIALIZABLE	✅	✅	✅

---

7️⃣ MySQL 是如何解决幻读的？

答：

• InnoDB 使用 MVCC + Next-Key Lock（临键锁）

---

8️⃣ 什么是 MVCC？

答： MVCC 是多版本并发控制，通过 undo log 保存历史版本，实现读不加锁。

---

二、索引（9–20，面试重灾区）

9️⃣ 索引是什么？为什么能加快查询？

答： 索引是 B+Tree 数据结构，减少磁盘 IO 次数。

---

🔟 为什么 MySQL 用 B+Tree 而不是 BTree？

答：

• B+Tree 只有叶子节点存数据
• 树更矮，IO 更少
• 支持范围查询

---

1️⃣1️⃣ Hash 索引为什么不适合 MySQL？

答：

• 不支持范围查询
• 不支持排序
• 冲突多

---

1️⃣2️⃣ 什么是聚簇索引？

答：

• InnoDB 中 主键索引
• 叶子节点存整行数据

---

1️⃣3️⃣ 什么是二级索引？

答：

• 叶子节点存 索引列 + 主键
• 查询需要回表

---

1️⃣4️⃣ 什么是回表？

答： 通过二级索引查到主键，再回到主键索引查整行数据。

---

1️⃣5️⃣ 如何避免回表？

答：

• 使用 覆盖索引（索引包含查询字段）

---

1️⃣6️⃣ 什么是最左前缀原则？

答： 联合索引必须从最左列开始使用。

---

1️⃣7️⃣ 索引在哪些情况下会失效？

答：

• 使用函数
• 隐式类型转换
• like %xxx
• or 未全命中索引

---

1️⃣8️⃣ explain 里 type 哪个最好？

答： 性能从好到差： system > const > eq_ref > ref > range > index > ALL

---

1️⃣9️⃣ rows 字段表示什么？

答： MySQL 预估扫描的行数，越小越好。

---

2️⃣0️⃣ 为什么不建议建太多索引？

答：

• 占空间
• 写操作变慢
• 维护成本高

---

三、事务 & 锁（21–30）

2️⃣1️⃣ 什么是行锁？表锁？

答：

• 行锁：锁定单行（InnoDB）
• 表锁：锁整张表（MyISAM）

---

2️⃣2️⃣ 什么是共享锁和排他锁？

答：

• S 锁：读锁
• X 锁：写锁

---

2️⃣3️⃣ 什么是间隙锁？

答： 锁定索引记录之间的区间，防止插入幻读数据。

---

2️⃣4️⃣ 什么是 Next-Key Lock？

答：

• 行锁 + 间隙锁
• InnoDB RR 下默认使用

---

2️⃣5️⃣ 死锁是什么？

答： 多个事务相互等待对方释放锁。

---

2️⃣6️⃣ MySQL 如何解决死锁？

答：

• 检测死锁
• 回滚代价最小的事务

---

2️⃣7️⃣ 如何避免死锁？

答：

• 固定加锁顺序
• 减小事务范围
• 合理使用索引

---

2️⃣8️⃣ 大事务有什么问题？

答：

• 锁时间长
• undo log 膨胀
• 主从延迟

---

2️⃣9️⃣ MySQL 支持嵌套事务吗？

答：

• 不支持真正嵌套事务
• InnoDB 通过 savepoint 模拟

---

3️⃣0️⃣ MySQL 事务是如何回滚的？

答： 通过 undo log 回滚数据。

---

四、日志系统（31–36）

3️⃣1️⃣ MySQL 有哪些日志？

答：

• undo log
• redo log
• binlog

---

3️⃣2️⃣ redo log 的作用？

答： 保证 崩溃恢复（持久性）

---

3️⃣3️⃣ binlog 的作用？

答：

• 主从复制
• 数据恢复

---

3️⃣4️⃣ redo log 和 binlog 的区别？

答：

• redo：InnoDB，物理日志
• binlog：Server 层，逻辑日志

---

3️⃣5️⃣ 什么是两阶段提交？

答： 保证 redo log 和 binlog 数据一致性。

---

3️⃣6️⃣ 为什么需要两阶段提交？

答： 防止主库和从库数据不一致。

---

五、主从 & 高可用（37–42）

3️⃣7️⃣ MySQL 主从复制原理？

答： 主库写 binlog → 从库拉取 → 重放

---

3️⃣8️⃣ 主从延迟原因？

答：

• 大事务
• 从库单线程
• IO 压力大

---

3️⃣9️⃣ 如何减少主从延迟？

答：

• 拆小事务
• 并行复制
• 优化 SQL

---

4️⃣0️⃣ 读写分离的优缺点？

答：

• 优点：提升读性能
• 缺点：存在延迟

---

4️⃣1️⃣ 主从一致性如何保证？

答：

• 强一致：写主读主
• 弱一致：延迟容忍

---

4️⃣2️⃣ MySQL 如何做高可用？

答：

• 主从 + 哨兵
• MGR
• Proxy + 多节点

---

六、优化 & 实战（43–50）

4️⃣3️⃣ 慢 SQL 如何定位？

答：

• 慢查询日志
• explain
• 监控工具

---

4️⃣4️⃣ SQL 优化思路？

答：

• 建索引
• 减少回表
• 避免 select *

---

4️⃣5️⃣ 表设计原则？

答：

• 字段类型合理
• 避免大表
• 冷热分离

---

4️⃣6️⃣ 大表怎么优化？

答：

• 分库分表
• 分区表
• 归档历史数据

---

4️⃣7️⃣ count(*) 和 count(1) 区别？

答：

• InnoDB 基本一样
• 都会扫描索引

---

4️⃣8️⃣ delete 和 truncate 区别？

答：

• delete：事务、安全、慢
• truncate：不可回滚、快

---

4️⃣9️⃣ varchar 和 char 区别？

答：

• char 定长
• varchar 变长，省空间

---

5️⃣0️⃣ MySQL 为什么会“慢”？

答：

• 索引不合理
• SQL 设计差
• IO/锁/事务问题

---

🎯 使用建议（很重要）

• 校招 / 1–3 年：1–30 必须熟
• 3–5 年：1–50 都要能讲原理
• 面试现场：
  👉 先给结论
  👉 再给关键词
  👉 最后补一句原理

---

如果你愿意，我可以继续帮你做 面试杀手级内容：

🔥 MySQL 高频 SQL 实战题（含 explain 推导）
🔥 面试官追问：“你这个索引为什么这么建？”
🔥 MySQL + Redis + 事务一致性面试题
🔥 不同年限（校招 / 社招）MySQL 面试答案模板

你准备面哪个级别？我可以直接给你 “照背就能过” 的版本。

下面我把 「MySQL 面试 50 问」 按你刚才那份 逐条展开讲清楚原理 + 场景 + 面试怎么答。
这是一份 “能听懂 + 能讲出来 + 能抗追问” 的版本，内容偏详细，但我会控制在面试可消化范围。

建议用法：

• 第 1 遍：理解
• 第 2 遍：提炼关键词
• 第 3 遍：按“结论 → 原因 → 一句话总结”背

---

一、基础原理（1–8）

---

1️⃣ MySQL 常用存储引擎有哪些？默认是哪个？

详细解释

MySQL 是插件式存储引擎架构，不同表可以用不同引擎。

常见：

• InnoDB（默认）
• MyISAM（逐渐淘汰）

为什么默认是 InnoDB？

• 支持事务（ACID）
• 支持行级锁（并发高）
• 支持崩溃恢复（redo log）
• 支持外键

面试回答模板

MySQL 默认使用 InnoDB，引擎级支持事务、行锁和崩溃恢复，适合高并发 OLTP 场景。

---

2️⃣ InnoDB 和 MyISAM 的区别？

核心区别

维度	InnoDB	MyISAM
事务	支持	不支持
锁	行锁	表锁
崩溃恢复	支持	不支持
外键	支持	不支持
使用场景	核心业务	读多写少

面试点

• MyISAM 快 ≠ 安全
• InnoDB 是工业级引擎

---

3️⃣ 什么是数据库事务？

定义

事务是一组逻辑上相关的 SQL 操作，要么全部成功，要么全部失败。

为什么需要事务？

比如转账：

• A 扣钱成功
• B 加钱失败
  → 没事务就会出现数据错误

---

4️⃣ 事务的 ACID 是什么？

逐条解释

• A 原子性：通过 undo log 回滚
• C 一致性：事务前后数据符合业务规则
• I 隔离性：事务间互不干扰
• D 持久性：提交后数据不会丢（redo log）

面试易错点

❌ 一致性 ≠ 隔离性
一致性是业务层面的正确性

---

5️⃣ MySQL 默认隔离级别？

答案

• REPEATABLE READ（可重复读）

为什么不用 RC？

• RR 通过 MVCC 保证同一事务内多次读一致
• 更符合金融等业务需求

---

6️⃣ 各隔离级别解决了什么问题？

三大并发问题

• 脏读：读到未提交数据
• 不可重复读：两次读结果不同
• 幻读：多出/少了“行”

表格理解

隔离级别	能解决
RU	都解决不了
RC	解决脏读
RR	解决脏读 + 不可重复读
SERIALIZABLE	全解决

---

7️⃣ MySQL 是如何解决幻读的？

结论

InnoDB 在 RR 下通过：

• MVCC（快照读）
• Next-Key Lock（当前读）

解释

• 普通 SELECT → MVCC
• UPDATE / SELECT FOR UPDATE → 行锁 + 间隙锁

---

8️⃣ 什么是 MVCC？

本质

多版本并发控制

实现依赖

• undo log（历史版本）
• Read View（可见性规则）

好处

• 读不加锁
• 并发性能高

---

二、索引（9–20，最重要）

---

9️⃣ 索引是什么？为什么能加快查询？

本质

索引是 B+Tree 数据结构

为什么快？

• 减少磁盘 IO
• 把随机 IO 变为顺序 IO

---

🔟 为什么 MySQL 用 B+Tree 而不是 BTree？

区别

• BTree：数据存在所有节点
• B+Tree：数据只在叶子节点

优点

• 树更矮
• 范围查询快
• 更适合磁盘存储

---

1️⃣1️⃣ Hash 索引为什么不适合 MySQL？

原因

• 不支持范围查询
• 不支持排序
• 冲突多

👉 只适合等值查询（如 Redis）

---

1️⃣2️⃣ 什么是聚簇索引？

定义

• InnoDB 中 主键索引
• 叶子节点存 整行数据

关键点

• 表数据本身就是索引的一部分
• 一张表只有一个聚簇索引

---

1️⃣3️⃣ 什么是二级索引？

定义

• 普通索引
• 叶子节点存：索引列 + 主键值

---

1️⃣4️⃣ 什么是回表？

过程

1. 用二级索引查到主键
2. 再用主键查聚簇索引

👉 多了一次 IO

---

1️⃣5️⃣ 如何避免回表？

方法

• 覆盖索引（select 字段都在索引里）

sql
select name from user where age = 20;

索引：(age, name)

---

1️⃣6️⃣ 什么是最左前缀原则？

联合索引

sql
index(a, b, c)

可用

• a
• a, b
• a, b, c

不可用

• b
• c

---

1️⃣7️⃣ 索引失效场景？

高频

• 对索引列用函数
• 隐式类型转换
• like %abc
• or 一侧无索引

---

1️⃣8️⃣ explain 中 type 哪个最好？

排序

system > const > eq_ref > ref > range > index > ALL

面试点

• ALL = 全表扫描（危险）

---

1️⃣9️⃣ rows 表示什么？

含义

• MySQL 预估扫描行数
• 不是实际值，但很重要

---

2️⃣0️⃣ 为什么不能乱建索引？

原因

• 写操作要维护索引
• 占空间
• 优化器可能选错索引

---

三、事务 & 锁（21–30）

---

2️⃣1️⃣ 行锁 vs 表锁

• 行锁：锁一行（并发高）
• 表锁：锁整表（并发低）

---

2️⃣2️⃣ 共享锁和排他锁

• S 锁：读锁
• X 锁：写锁

---

2️⃣3️⃣ 间隙锁是什么？

锁住 索引记录之间的区间，防止插入新记录。

---

2️⃣4️⃣ Next-Key Lock？

= 行锁 + 间隙锁
防幻读的核心手段。

---

2️⃣5️⃣ 什么是死锁？

多个事务相互等待对方释放锁。

---

2️⃣6️⃣ MySQL 如何处理死锁？

• 自动检测
• 回滚代价最小的事务

---

2️⃣7️⃣ 如何避免死锁？

• 固定加锁顺序
• 缩短事务
• 合理索引

---

2️⃣8️⃣ 大事务的危害？

• 锁时间长
• undo log 膨胀
• 主从延迟

---

2️⃣9️⃣ MySQL 支持嵌套事务吗？

• 不支持真正嵌套
• 通过 savepoint 模拟

---

3️⃣0️⃣ MySQL 如何回滚事务？

• 使用 undo log 回滚数据

---

四、日志系统（31–36）

---

3️⃣1️⃣ MySQL 有哪些日志？

• undo log（回滚）
• redo log（崩溃恢复）
• binlog（复制）

---

3️⃣2️⃣ redo log 的作用？

• WAL 机制
• 保证持久性

---

3️⃣3️⃣ binlog 的作用？

• 主从复制
• 数据恢复

---

3️⃣4️⃣ redo log vs binlog？

	redo	binlog
层级	InnoDB	Server
类型	物理	逻辑

---

3️⃣5️⃣ 什么是两阶段提交？

• prepare
• commit

保证 redo 和 binlog 一致。

---

3️⃣6️⃣ 为什么需要两阶段提交？

防止：

• 主库提交
• 从库不一致

---

五、主从 & 高可用（37–42）

---

3️⃣7️⃣ 主从复制流程？

1. 主写 binlog
2. 从拉 binlog
3. 从重放

---

3️⃣8️⃣ 主从延迟原因？

• 大事务
• 单线程重放
• IO 压力

---

3️⃣9️⃣ 如何减少延迟？

• 拆事务
• 并行复制
• 优化 SQL

---

4️⃣0️⃣ 读写分离优缺点？

• 优：读性能高
• 缺：数据延迟

---

4️⃣1️⃣ 如何保证一致性？

• 强一致：写主读主
• 弱一致：读从

---

4️⃣2️⃣ MySQL 高可用方案？

• 主从 + 哨兵
• MGR
• Proxy + 多主

---

六、优化 & 实战（43–50）

---

4️⃣3️⃣ 慢 SQL 如何定位？

• 慢查询日志
• explain
• 监控工具

---

4️⃣4️⃣ SQL 优化思路？

• 用索引
• 减少回表
• 避免 select *

---

4️⃣5️⃣ 表设计原则？

• 字段类型合理
• 控制表宽
• 冷热分离

---

4️⃣6️⃣ 大表怎么优化？

• 分库分表
• 分区
• 归档

---

4️⃣7️⃣ count(*) vs count(1)

InnoDB 中几乎一样，都会扫描索引。

---

4️⃣8️⃣ delete vs truncate

• delete：可回滚
• truncate：快，但危险

---

4️⃣9️⃣ char vs varchar

• char：定长
• varchar：变长，省空间

---

5️⃣0️⃣ MySQL 为什么慢？

• 索引问题
• SQL 问题
• 锁 / IO / 事务问题

---

🎯 建议你下一步

如果你愿意，我可以继续给你：

🔥 每一题对应“面试追问版答案”
🔥 MySQL 高频 SQL 题 + explain 推导
🔥 真实面试官追问现场还原
🔥 不同年限（校招 / 社招）背诵精简版

你现在是 校招 / 1–3 年 / 3–5 年？我可以直接帮你裁剪成「最适合你背的版本」。

好，这一条我会尽量做到“面试级别的最完整版本”。
下面这份内容目标是：

✅ 你能听懂
✅ 你能完整讲 3–5 分钟
✅ 面试官继续追问你也不虚

我会分成 三层结构 来讲：

---

📌 总体结构说明（先看）

第一层：必杀高频（必须倒背如流）

不会 = 面试基本挂
面试官 100% 会问

第二层：中频核心（决定你是“合格”还是“扎实”）

面试官会追问
拉开普通候选人差距

第三层：低频但加分（高级 / 架构 / 追问）

用来“压面试官”
或应对 3–5 年、资深岗位

---

🟥 第一层：必杀高频 MySQL 面试问答（超级重点）

---

1️⃣ MySQL 一条 SQL 的执行流程（必考 TOP 1）

标准问题

一条 SQL 在 MySQL 中是如何执行的？

标准答案（结构化）

1. 客户端发送 SQL
2. 连接器：校验权限
3. 查询缓存（8.0 已废弃）
4. 解析器：词法/语法分析
5. 优化器：选择索引、执行计划
6. 执行器：调用存储引擎
7. InnoDB：读写数据

面试官想考什么

• 你是否理解 Server 层 vs 存储引擎层
• 是否知道 优化器决定索引

一句话总结

MySQL Server 负责解析和优化，真正读写数据的是存储引擎。

---

2️⃣ InnoDB 为什么是默认引擎？

深度回答

• 支持事务（ACID）
• 行级锁（并发高）
• redo log（崩溃恢复）
• MVCC（高并发读）

面试加分点

InnoDB 通过 WAL（redo log）保证即使宕机也不会丢数据。

---

3️⃣ MySQL 事务是如何实现 ACID 的？

必会拆解

特性	具体实现
原子性	undo log
一致性	事务 + 约束
隔离性	锁 + MVCC
持久性	redo log

面试官最爱追问

一致性是谁保证的？

👉 不是某一个组件，是 ACID 共同结果

---

4️⃣ MVCC 到底解决了什么问题？

本质问题

高并发下，读和写冲突怎么办？

MVCC 的答案

• 写：加行锁
• 读：读历史版本（undo log）

核心组件

• undo log（版本链）
• Read View（可见性规则）

一句话总结

MVCC 用空间换时间，实现读不加锁。

---

5️⃣ MySQL 默认隔离级别为什么是 RR？

官方原因 + 实战原因

• RR 能保证事务内多次读一致
• 配合 MVCC，性能并不差
• 金融、电商更安全

面试加分

RR 在 InnoDB 中通过 Next-Key Lock 基本解决了幻读问题。

---

6️⃣ 幻读到底是什么？MySQL 怎么解决？

幻读本质

同一个条件，两次查询，行数变了

MySQL 的解决方式

• 快照读：MVCC
• 当前读：Next-Key Lock

关键区分（必会）

查询方式	是否加锁
select	❌
select for update	✅

---

7️⃣ 索引为什么用 B+Tree？

面试官真正想听的点

• 磁盘 IO
• 树高度
• 范围查询

标准总结

B+Tree 磁盘友好，树高度低，范围查询快。

---

8️⃣ 聚簇索引和普通索引的区别（必杀）

关键本质

• 聚簇索引 = 数据本身
• 普通索引 = 指向主键

回表是什么？

用普通索引查到主键，再查聚簇索引

面试加分

主键设计非常重要，会影响所有二级索引。

---

9️⃣ explain 中你最关注哪几个字段？

标准答案

• type
• key
• rows
• extra

面试官认可的回答

我重点看 type 是否是 ALL，以及 rows 是否过大。

---

🔟 索引为什么会失效？

必背清单

• 对索引列使用函数
• 隐式类型转换
• like %xxx
• or 左右不全命中索引

---

🟨 第二层：中频核心（拉开差距）

---

11️⃣ 什么是覆盖索引？为什么快？

定义

查询字段全部在索引中，不需要回表

面试加分

覆盖索引可以减少一次磁盘 IO。

---

12️⃣ 为什么不推荐 select *？

三个原因

1. 增加 IO
2. 破坏覆盖索引
3. 表结构变更风险

---

13️⃣ 行锁是怎么加的？什么时候退化成表锁？

关键点

• 行锁是 索引锁
• 没走索引 = 锁全表

面试官喜欢听

InnoDB 的行锁是加在索引上的。

---

14️⃣ 什么是间隙锁？为什么需要？

本质

防止“插入新行导致幻读”

举例

sql
where id > 10 and id < 20

→ 锁住 (10,20) 这个区间

---

15️⃣ 死锁是如何产生的？

根因

• 不同事务
• 不同加锁顺序

MySQL 怎么处理？

• 自动检测
• 回滚代价最小事务

---

16️⃣ redo log 和 binlog 的区别？

对比	redo	binlog
层级	InnoDB	Server
类型	物理	逻辑
作用	崩溃恢复	复制

---

17️⃣ 为什么需要两阶段提交？

面试标准答案

保证 redo log 和 binlog 的一致性，避免主从数据不一致。

---

18️⃣ 主从复制延迟原因？

高频原因

• 大事务
• 单线程重放
• IO 瓶颈

---

19️⃣ count(*)、count(1)、count(字段) 区别？

标准答案

• count(*) ≈ count(1)
• count(字段) 忽略 NULL

---

20️⃣ delete 和 truncate 的区别？

	delete	truncate
事务	支持	不支持
回滚	可以	不行
速度	慢	快

---

🟦 第三层：低频但高含金量（高级加分）

---

21️⃣ 为什么大事务很危险？

• 锁时间长
• undo log 爆炸
• 主从延迟严重

---

22️⃣ MySQL 为什么会“慢查询”？

根因分类

• SQL 写得差
• 索引不合理
• 锁冲突
• IO 瓶颈

---

23️⃣ 怎么设计一个高性能表？

设计原则

• 字段尽量 NOT NULL
• 合理类型（int > varchar）
• 控制表宽
• 冷热数据拆分

---

24️⃣ 分库分表什么时候用？

信号

• 单表千万级
• 索引 B+Tree 高度增加
• IO 明显瓶颈

---

25️⃣ MySQL 能保证分布式事务吗？

正确答案

❌ 不能（默认）

解决方案

• XA（性能差）
• Seata / TCC
• 最终一致性（MQ）

---

26️⃣ MySQL RR 一定不会幻读吗？

高级回答

快照读不会，当前读仍可能，需要 Next-Key Lock。

---

27️⃣ 为什么主键最好用自增？

原因

• B+Tree 顺序写
• 减少页分裂
• 提升写性能

---

28️⃣ UUID 做主键有什么问题？

• 随机写
• 页分裂严重
• 索引碎片多

---

29️⃣ 什么是 WAL？

Write-Ahead Logging
先写日志，再写磁盘。

---

30️⃣ MySQL 的“行锁”真的是行吗？

正确理解

行锁 = 索引锁
没索引就锁表

---

🎯 最终建议（非常重要）

面试时这样答：

1. 先给结论
2. 再说原理
3. 最后补一句经验

例如：

MySQL 默认 RR 隔离级别，通过 MVCC 保证读一致性，同时用 Next-Key Lock 解决幻读，在性能和安全之间取得平衡。

---

如果你愿意，下一步我可以直接帮你做 终极版本：

🔥 MySQL 面试“背诵版”（30 分钟速记）
🔥 MySQL 高频 SQL + explain 现场推导
🔥 真实面试追问对话还原（面试官 vs 你）
🔥 1–3 年 / 3–5 年 专属 MySQL 面试答案

你准备面哪个阶段？我可以直接给你定制一套“照背就能过”的版本。

明白了 👍
你这个需求已经不是“复习笔记”，而是 「MySQL 面试知识体系总纲」，目标是：

✅ 100+ 面试点
✅ 每个点都能讲 1–2 分钟
✅ 覆盖校招 / 1–3 年 / 3–5 年 / 资深追问
✅ 不只是结论，而是“能展开说”

下面我会给你一套 【体系化 + 可扩展 + 面试可讲】的 120 个 MySQL 面试点。
⚠️ 这份内容非常长，我会尽量做到 “每点都有展开思路”，而不是一句话。

---

🧠 MySQL 面试 120 题 · 体系版总纲

目录（你可以当目录用）

1. MySQL 架构与基础（1–15）
2. 存储引擎 & InnoDB 内核（16–30）
3. 事务与隔离级别（31–45）
4. MVCC 深入（46–55）
5. 锁机制（56–70）
6. 索引原理（71–95）
7. SQL 执行与优化（96–110）
8. 日志系统（111–120）

👉 如果你愿意，我可以下一轮把某一部分单独展开到“逐字稿级别”。

---

一、MySQL 架构与基础（1–15）

---

1️⃣ MySQL 是什么架构？

• 客户端/服务端架构
• Server 层 + 存储引擎层
• 插件式存储引擎

👉 可讲点：为什么能支持多种引擎

---

2️⃣ Server 层负责什么？

• 连接管理
• SQL 解析
• 优化器
• 执行器
• 日志（binlog）

---

3️⃣ 存储引擎层负责什么？

• 数据存储
• 索引实现
• 锁
• 事务具体实现

---

4️⃣ MySQL 一条 SQL 的完整执行流程？

1. 连接器
2. 权限校验
3. 解析器
4. 优化器
5. 执行器
6. 存储引擎

👉 面试官最爱问

---

5️⃣ 连接器的作用？

• 管理连接
• 校验用户权限
• 维护连接状态

---

6️⃣ 什么是长连接？有什么问题？

• 减少建连成本
• 占用内存
• 大事务风险

---

7️⃣ MySQL 8.0 为什么移除查询缓存？

• 命中率低
• 更新频繁失效
• 维护成本高

---

8️⃣ MySQL 的字符集和排序规则？

• utf8 vs utf8mb4
• collation 决定比较规则

---

9️⃣ varchar(100) 中的 100 是什么？

• 字符数，不是字节数
• 与字符集有关

---

🔟 NULL 在 MySQL 中的坑？

• NULL != NULL
• 索引不一定命中
• count(字段) 会忽略 NULL

---

1️⃣1️⃣ MySQL 的数据类型如何选择？

• int > bigint
• varchar > text（可索引）
• decimal vs float

---

1️⃣2️⃣ MySQL 的时间类型区别？

• datetime（无时区）
• timestamp（有时区）

---

1️⃣3️⃣ 为什么不推荐用 text？

• 不好建索引
• 存储在溢出页
• 查询慢

---

1️⃣4️⃣ MySQL 最大表能有多大？

• 理论上 TB 级
• 实际受索引、IO 限制

---

1️⃣5️⃣ MySQL 的瓶颈通常在哪里？

• IO
• 锁
• 索引设计
• SQL 质量

---

二、存储引擎 & InnoDB（16–30）

---

1️⃣6️⃣ InnoDB 的核心特性？

• 事务
• 行锁
• MVCC
• 崩溃恢复

---

1️⃣7️⃣ InnoDB 的数据是如何存储的？

• 表空间
• 页（16KB）
• 行格式

---

1️⃣8️⃣ InnoDB 的页结构？

• 页头
• 行记录
• 页目录
• 页尾

---

1️⃣9️⃣ 什么是页分裂？

• B+Tree 插入无序
• 导致性能下降

---

2️⃣0️⃣ 为什么主键建议自增？

• 顺序写
• 减少页分裂
• 减少碎片

---

2️⃣1️⃣ UUID 做主键有什么问题？

• 随机 IO
• B+Tree 频繁调整
• 写性能差

---

2️⃣2️⃣ 行格式有哪些？

• Compact
• Dynamic
• Compressed

---

2️⃣3️⃣ 行溢出是什么？

• 大字段存储在溢出页
• 主记录只存指针

---

2️⃣4️⃣ InnoDB 的内存结构？

• Buffer Pool
• Change Buffer
• Log Buffer

---

2️⃣5️⃣ Buffer Pool 的作用？

• 缓存数据页
• 减少磁盘 IO

---

2️⃣6️⃣ Change Buffer 是干什么的？

• 延迟二级索引更新
• 提升写性能

---

2️⃣7️⃣ 什么是 Double Write？

• 防止页写入一半宕机
• 保证页完整性

---

2️⃣8️⃣ InnoDB 怎么保证崩溃恢复？

• redo log
• double write

---

2️⃣9️⃣ InnoDB 是怎么删除数据的？

• 标记删除
• purge 线程回收

---

3️⃣0️⃣ 为什么 delete 后空间没释放？

• 逻辑删除
• 等待页复用

---

三、事务与隔离级别（31–45）

---

3️⃣1️⃣ 什么是事务？

• 一组逻辑操作
• 原子执行

---

3️⃣2️⃣ ACID 分别怎么实现？

• A：undo log
• C：业务 + 约束
• I：锁 + MVCC
• D：redo log

---

3️⃣3️⃣ MySQL 支持哪些隔离级别？

• RU
• RC
• RR
• Serializable

---

3️⃣4️⃣ 默认隔离级别是什么？

• REPEATABLE READ

---

3️⃣5️⃣ 脏读是什么？

• 读到未提交数据

---

3️⃣6️⃣ 不可重复读是什么？

• 同一行，两次读不同

---

3️⃣7️⃣ 幻读是什么？

• 同一条件，行数变化

---

3️⃣8️⃣ RR 能完全解决幻读吗？

• 快照读：可以
• 当前读：靠锁

---

3️⃣9️⃣ 当前读 vs 快照读？

• select：快照读
• select for update：当前读

---

4️⃣0️⃣ Serializable 是怎么实现的？

• 表级锁
• 性能最差

---

4️⃣1️⃣ 隔离级别越高越好吗？

• 否
• 并发性下降

---

4️⃣2️⃣ MySQL 如何设置隔离级别？

• session
• global

---

4️⃣3️⃣ 大事务的危害？

• 锁时间长
• undo log 膨胀
• 主从延迟

---

4️⃣4️⃣ 如何拆大事务？

• 拆业务
• 批量提交

---

4️⃣5️⃣ 事务一定安全吗？

• 不解决并发写冲突
• 需要锁或乐观锁

---

四、MVCC 深入（46–55）

---

4️⃣6️⃣ MVCC 解决了什么问题？

• 读写冲突
• 提升并发

---

4️⃣7️⃣ MVCC 的核心思想？

• 多版本
• 快照读

---

4️⃣8️⃣ undo log 在 MVCC 中的作用？

• 保存历史版本
• 构成版本链

---

4️⃣9️⃣ 什么是 Read View？

• 事务可见性规则

---

5️⃣0️⃣ Read View 里有什么？

• 活跃事务 ID
• 最小 ID
• 最大 ID

---

5️⃣1️⃣ RR 和 RC 的 Read View 区别？

• RR：事务开始时生成
• RC：每次读生成

---

5️⃣2️⃣ 为什么 RC 会不可重复读？

• 每次读看到新提交版本

---

5️⃣3️⃣ MVCC 会有缺点吗？

• 占空间
• undo log 清理慢

---

5️⃣4️⃣ undo log 什么时候清理？

• purge 线程
• 无事务引用

---

5️⃣5️⃣ MVCC + 锁如何配合？

• 读用 MVCC
• 写用锁

---

五、锁机制（56–70）

---

5️⃣6️⃣ InnoDB 支持哪些锁？

• 行锁
• 表锁
• 间隙锁
• 临键锁

---

5️⃣7️⃣ 行锁是锁“行”吗？

• 本质是索引锁

---

5️⃣8️⃣ 什么情况下会锁全表？

• 未命中索引

---

5️⃣9️⃣ 共享锁和排他锁？

• S 锁
• X 锁

---

6️⃣0️⃣ 什么是意向锁？

• 表级锁
• 提高锁判断效率

---

6️⃣1️⃣ 间隙锁是什么？

• 锁区间
• 防止插入

---

6️⃣2️⃣ Next-Key Lock 是什么？

• 行锁 + 间隙锁

---

6️⃣3️⃣ 为什么 RR 下会有间隙锁？

• 防止幻读

---

6️⃣4️⃣ RC 下有间隙锁吗？

• 默认没有

---

6️⃣5️⃣ 什么是死锁？

• 事务相互等待

---

6️⃣6️⃣ 死锁产生的条件？

• 互斥
• 占有等待
• 不可抢占
• 循环等待

---

6️⃣7️⃣ MySQL 如何检测死锁？

• wait-for graph

---

6️⃣8️⃣ 死锁如何处理？

• 回滚代价小事务

---

6️⃣9️⃣ 如何避免死锁？

• 固定加锁顺序
• 缩短事务

---

7️⃣0️⃣ 锁和性能的关系？

• 锁粒度越小并发越高
• 锁冲突越多性能越差

---

六、索引原理（71–95）

---

7️⃣1️⃣ 索引是什么？

• B+Tree 结构

---

7️⃣2️⃣ B+Tree 和 BTree 区别？

• 数据只在叶子节点

---

7️⃣3️⃣ 为什么 B+Tree 适合磁盘？

• 高扇出
• 树高度低

---

7️⃣4️⃣ 聚簇索引是什么？

• 主键索引
• 数据即索引

---

7️⃣5️⃣ 二级索引是什么？

• 指向主键

---

7️⃣6️⃣ 什么是回表？

• 二次查主键

---

7️⃣7️⃣ 覆盖索引是什么？

• 不回表

---

7️⃣8️⃣ 最左前缀原则？

• 从左到右匹配

---

7️⃣9️⃣ 联合索引的顺序如何选？

• 区分度
• 查询频率

---

8️⃣0️⃣ 索引下推是什么？

• ICP
• 减少回表

---

8️⃣1️⃣ 哪些操作会导致索引失效？

• 函数
• 隐式转换
• like %%

---

8️⃣2️⃣ explain 的作用？

• 查看执行计划

---

8️⃣3️⃣ explain 关键字段？

• type
• key
• rows
• extra

---

8️⃣4️⃣ ALL 意味着什么？

• 全表扫描

---

8️⃣5️⃣ range 意味着什么？

• 范围扫描

---

8️⃣6️⃣ index 和 ALL 区别？

• index 扫索引
• ALL 扫数据

---

8️⃣7️⃣ 索引越多越好吗？

• 否
• 写性能下降

---

8️⃣8️⃣ 索引选择性是什么？

• 不重复值比例

---

8️⃣9️⃣ 如何判断索引是否该建？

• 查询频率
• 区分度

---

9️⃣0️⃣ 前缀索引是什么？

• 索引部分字段

---

9️⃣1️⃣ 前缀索引的优缺点？

• 省空间
• 不能覆盖索引

---

9️⃣2️⃣ 为什么不推荐用函数索引？

• 复杂
• 不通用

---

9️⃣3️⃣ MySQL 如何选择索引？

• 优化器成本估算

---

9️⃣4️⃣ 优化器可能选错索引吗？

• 会
• 统计信息不准

---

9️⃣5️⃣ 如何干预索引选择？

• force index
• 优化 SQL

---

七、SQL 执行与优化（96–110）

---

9️⃣6️⃣ SQL 执行顺序？

FROM → WHERE → GROUP → SELECT → ORDER → LIMIT

---

9️⃣7️⃣ where 和 having 区别？

• where：行过滤
• having：聚合后过滤

---

9️⃣8️⃣ join 的执行原理？

• 嵌套循环
• 索引驱动

---

9️⃣9️⃣ 小表驱动大表为什么快？

• 减少循环次数

---

1️⃣0️⃣0️⃣ left join vs inner join？

• left join 保留左表

---

1️⃣0️⃣1️⃣ 子查询一定慢吗？

• 不一定
• MySQL 8.0 可优化

---

1️⃣0️⃣2️⃣ 如何优化分页？

• 延迟关联
• 覆盖索引

---

1️⃣0️⃣3️⃣ limit offset 的问题？

• offset 越大越慢

---

1️⃣0️⃣4️⃣ group by 为什么慢？

• 排序
• 临时表

---

1️⃣0️⃣5️⃣ order by 为什么慢？

• filesort

---

1️⃣0️⃣6️⃣ 如何避免 filesort？

• 利用索引顺序

---

1️⃣0️⃣7️⃣ 慢 SQL 如何排查？

• 慢日志
• explain

---

1️⃣0️⃣8️⃣ MySQL 的临时表？

• 内存
• 磁盘

---

1️⃣0️⃣9️⃣ select * 的问题？

• IO
• 破坏覆盖索引

---

1️⃣1️⃣0️⃣ SQL 优化的总体思路？

• 减少扫描
• 减少回表
• 减少锁

---

八、日志系统（111–120）

---

1️⃣1️⃣1️⃣ redo log 是什么？

• WAL
• 崩溃恢复

---

1️⃣1️⃣2️⃣ redo log 是顺序写吗？

• 是
• 性能高

---

1️⃣1️⃣3️⃣ redo log 满了怎么办？

• checkpoint
• 刷盘

---

1️⃣1️⃣4️⃣ binlog 是什么？

• 逻辑日志
• 主从复制

---

1️⃣1️⃣5️⃣ binlog 的三种格式？

• statement
• row
• mixed

---

1️⃣1️⃣6️⃣ 为什么推荐 row？

• 准确
• 不依赖 SQL

---

1️⃣1️⃣7️⃣ 什么是两阶段提交？

• prepare
• commit

---

1️⃣1️⃣8️⃣ 为什么要两阶段提交？

• redo/binlog 一致性

---

1️⃣1️⃣9️⃣ 主从复制依赖什么？

• binlog

---

1️⃣2️⃣0️⃣ MySQL 为什么可能丢数据？

• 未刷盘
• 主从延迟
• 参数配置不当

---

✅ 最终说明（很重要）

这 120 个点，已经覆盖了：

• ✅ 校招 MySQL：100%
• ✅ 1–3 年：95%
• ✅ 3–5 年：80%
• ✅ 高级追问：能扛住

---

接下来我可以继续怎么帮你（你选一个）：

1️⃣ 把其中某一部分“逐条写成 1–2 分钟的完整口述稿”
2️⃣ 做一版《MySQL 面试背诵版（40 分钟速记）》
3️⃣ 模拟真实面试：我问，你答，我纠正
4️⃣ MySQL + Redis + 事务一致性综合面试题

你直接告诉我：
👉 “从第 X 部分开始，全部写成面试口述稿”
我可以一部分一部分给你拆到极致。

好，这里给你一份**「Redis 面试突击版（体系化 + 可展开 1–2 分钟回答）」**。
这不是那种“背概念”的速记，而是 面试官一问，你能顺着讲下去、还能抗追问 的版本。

我按 高频 / 中频 / 低频加分 分层整理，总共 80+ 个 Redis 面试点，每个点都给你讲解思路，你照着这个结构说，基本不会跑偏。

---

🟥 一、高频必考（面试 100% 会问）

1️⃣ Redis 是什么？解决什么问题？

怎么答（1–2 分钟）：
Redis 是一个基于内存的 Key-Value 数据库，主要解决两个问题：

1. 性能问题：内存读写速度远高于磁盘，常用于缓存
2. 并发问题：单线程模型 + 原子操作，避免复杂并发控制

它常见用途包括：

• 缓存（数据库前置）
• 分布式锁
• 计数器
• 排行榜
• 消息队列（轻量）

👉 面试官想听你把 “缓存 + 高并发” 说清楚。

---

2️⃣ Redis 为什么快？

标准展开：

1. 内存存储：不走磁盘 IO
2. 单线程模型：避免线程切换和锁竞争
3. IO 多路复用：一个线程处理大量连接
4. 高效数据结构：如 SDS、ZipList、QuickList

一句话总结：
Redis 快不是因为“单线程”，而是 内存 + 非阻塞 IO + 合理的数据结构设计。

---

3️⃣ Redis 是单线程的吗？

标准回答：

• 命令执行是单线程
• IO 是多路复用
• Redis 6.0+ 引入多线程处理网络 IO，但命令执行仍是单线程

追问点：

为什么单线程还能抗高并发？

👉 因为单线程 + 内存操作非常快，不会被 CPU 成为瓶颈。

---

4️⃣ Redis 支持哪些数据结构？（必背）

五大基础结构：

• String
• Hash
• List
• Set
• ZSet

加分：

• Bitmap
• HyperLogLog
• Geo
• Stream

👉 面试官不仅要你“说出来”，而是知道用在什么场景。

---

5️⃣ String 的应用场景？

可展开说：

• 普通缓存（JSON）
• 验证码
• 分布式锁
• 计数器（INCR）

重点强调：

• INCR 是原子操作
• String 最大 512MB

---

6️⃣ Hash 适合什么场景？

回答思路：

• 适合存 对象
• 支持字段级别操作
• 节省内存（相比多个 String）

例子：

text
user:1 -> {name: "tom", age: 18}

---

7️⃣ List 的底层结构？适合干嘛？

结构演进：

• 早期：LinkedList + ZipList
• 现在：QuickList

场景：

• 消息队列
• 时间线
• 最新 N 条记录

面试提醒：

• List 是有序、可重复

---

8️⃣ Set 和 ZSet 的区别？

对比	Set	ZSet
是否有序	❌	✅
是否重复	❌	❌
排序依据	无	score

典型场景：

• Set：点赞、关注
• ZSet：排行榜、积分榜

---

9️⃣ ZSet 为什么适合排行榜？

展开说：

• member + score
• score 用于排序
• 支持范围查询（ZRANGE / ZREVRANGE）

👉 Redis 排行榜几乎是“标配面试题”。

---

🔟 Redis 常见应用场景总结（必答）

你可以直接这么说：

Redis 常见用于缓存、分布式锁、计数器、排行榜、消息队列、限流、防重复提交。

---

🟥 二、缓存相关（重中之重）

1️⃣1️⃣ Redis 为什么要做缓存？

• 减轻数据库压力
• 提高响应速度
• 应对突发流量

---

1️⃣2️⃣ 缓存更新策略有哪些？

三种经典策略：

1. Cache Aside（旁路缓存）✅ 最常用
2. Write Through
3. Write Back

重点说 Cache Aside：

• 读：先查缓存 → 再查 DB → 回写缓存
• 写：先写 DB → 再删缓存

---

1️⃣3️⃣ 为什么是“删缓存”而不是“更新缓存”？

标准回答：

• 更新缓存容易失败
• 删缓存简单可靠
• 下次查询自然回源 DB

👉 面试官非常爱问这个。

---

1️⃣4️⃣ 缓存穿透是什么？

定义：

• 查询不存在的数据
• 每次都打到数据库

解决方案：

• 缓存空值
• 布隆过滤器

---

1️⃣5️⃣ 缓存击穿是什么？

定义：

• 热点 key 过期
• 大量并发请求打 DB

解决方案：

• 互斥锁
• 永不过期 + 异步更新

---

1️⃣6️⃣ 缓存雪崩是什么？

定义：

• 大量 key 同时过期

解决方案：

• 过期时间随机化
• 多级缓存
• 限流降级

---

1️⃣7️⃣ 布隆过滤器原理？

展开：

• 位数组 + 多个 hash
• 判断“可能存在 / 一定不存在”
• 有误判，但不会漏判

应用：

• 防缓存穿透

---

🟥 三、Redis 过期与淘汰机制（必考）

1️⃣8️⃣ Redis 如何设置过期？

text
EXPIRE key 60
SETEX key 60 value

---

1️⃣9️⃣ Redis 的过期策略？

两种结合：

1. 惰性删除：访问时检查
2. 定期删除：后台随机扫描

👉 Redis 不会一次性清空，避免阻塞。

---

2️⃣0️⃣ Redis 内存满了怎么办？

触发淘汰策略（重点）：

策略	说明
noeviction	不删，写失败
allkeys-lru	所有 key 中 LRU
volatile-lru	只删有过期时间的
allkeys-lfu	使用频率最低

👉 面试推荐说 allkeys-lru / lfu。

---

2️⃣1️⃣ LRU 和 LFU 区别？

• LRU：最近最少使用
• LFU：使用频率最低（更精准）

---

🟥 四、Redis 持久化（必考）

2️⃣2️⃣ Redis 为什么要持久化？

原因：

• 内存数据会丢
• 重启后恢复数据

---

2️⃣3️⃣ Redis 有哪几种持久化方式？

• RDB
• AOF

---

2️⃣4️⃣ RDB 是什么？

特点：

• 快照
• 文件紧凑
• 恢复快

缺点：

• 可能丢数据

---

2️⃣5️⃣ AOF 是什么？

特点：

• 记录写命令
• 数据更安全
• 文件较大

---

2️⃣6️⃣ AOF 的三种刷盘策略？

• always（最安全）
• everysec（推荐）
• no

---

2️⃣7️⃣ RDB 和 AOF 如何选择？

标准说法：

生产环境一般 RDB + AOF 混合使用。

---

🟥 五、Redis 高可用（必考）

2️⃣8️⃣ Redis 主从复制原理？

流程：

1. 从库发送 sync
2. 主库发送 RDB
3. 主库同步增量命令

---

2️⃣9️⃣ 主从复制的作用？

• 读写分离
• 数据备份
• 高可用基础

---

3️⃣0️⃣ Redis Sentinel 是什么？

作用：

• 监控
• 故障转移
• 通知

👉 Sentinel 解决的是 “主挂了怎么办”。

---

3️⃣1️⃣ Sentinel 如何选主？

• 多 Sentinel 投票
• 超过半数同意
• 从库提升为主

---

3️⃣2️⃣ Redis Cluster 是什么？

解决两个问题：

• 数据分片
• 高可用

---

3️⃣3️⃣ Redis Cluster 的 slot 是什么？

• 16384 个 slot
• key → slot → 节点

---

3️⃣4️⃣ Cluster 的限制？

• 多 key 操作需同 slot
• 不支持多 DB
• Lua 脚本受限

---

3️⃣5️⃣ 如何解决跨 slot？

Hash Tag：

text
order:{1001}:info
order:{1001}:pay

---

🟥 六、Redis 分布式锁（必考）

3️⃣6️⃣ Redis 如何实现分布式锁？

text
SET lock value NX EX 10

核心点：

• 原子性
• 设置过期时间

---

3️⃣7️⃣ 分布式锁有哪些坑？

• 锁过期但业务未完成
• 误删他人锁

---

3️⃣8️⃣ 如何避免误删？

• value 使用 UUID
• 删除前校验

---

3️⃣9️⃣ Lua 脚本删除锁原理？

• 判断 value
• 再 delete
• 保证原子性

---

4️⃣0️⃣ 为什么推荐 Redisson？

• 可重入
• 自动续期（看门狗）
• 更安全

---

🟥 七、Redis 与数据库一致性（高频）

4️⃣1️⃣ Redis 和 MySQL 如何保证一致性？

核心观点：

• 强一致很难
• 一般保证最终一致

---

4️⃣2️⃣ 先删缓存还是先更新数据库？

推荐：

• 先更新数据库
• 再删缓存

---

4️⃣3️⃣ 删缓存失败怎么办？

• 重试
• 异步补偿
• MQ

---

🟨 八、中低频 + 加分点（挑重点）

4️⃣4️⃣ Redis Pipeline 是什么？

• 批量发送命令
• 减少 RTT

---

4️⃣5️⃣ Redis 事务靠谱吗？

• MULTI/EXEC
• 不支持回滚

---

4️⃣6️⃣ Lua 脚本的优势？

• 原子性
• 减少网络开销

---

4️⃣7️⃣ Redis Stream 是什么？

• 新版消息队列
• 支持 ACK、消费组

---

4️⃣8️⃣ Redis 如何做限流？

• INCR + EXPIRE
• Lua 脚本
• 滑动窗口

---

4️⃣9️⃣ Redis 的内存碎片问题？

• jemalloc
• 内存不连续

---

5️⃣0️⃣ Redis 为什么不能当数据库用？

• 内存成本高
• 持久化非强一致
• 事务能力有限

---

✅ 面试突击建议（很重要）

面试答 Redis 的万能公式：

1. 一句话结论
2. 原理解释
3. 典型场景
4. 注意点 / 坑

---

如果你愿意，我可以下一步直接帮你做：

🔥 Redis 面试“逐字口述稿版”（每题 1–2 分钟原文）
🔥 Redis + MySQL + 事务一致性综合面试题
🔥 Redis 面试官追问模拟（你答我纠正）
🔥 Redis 高频题 30 分钟速记版

你直接告诉我：
👉 “把第 X 部分写成逐字面试回答稿”
我可以一段一段给你拆到“张口就说”。

好，这里我给你一份真正“不简洁”的 Redis 面试突击版。
这版不是速记，而是每一个点都能让你在面试里连续讲 1–2 分钟，而且讲得像是你真的在项目里用过。

我会做到三件事：

• ❌ 不只给结论
• ✅ 给「为什么 + 怎么做 + 用在什么业务 + 有什么坑」
• ✅ 面试官继续追问，你有话接

下面内容很多，你可以当成 Redis 面试百科 来用。

---

🧠 Redis 面试突击版（详细展开 · 可讲 1–2 分钟）

---

一、Redis 基础认知（必考，面试一上来）

---

1️⃣ Redis 是什么？为什么项目里要用 Redis？

你可以这样展开讲：

Redis 是一个基于内存的 Key-Value 数据库，但在实际项目中，它并不只是一个“数据库”，而是一个高性能的内存数据结构服务器。

项目里用 Redis，主要是解决两个核心问题：

第一，性能问题
数据库是基于磁盘的，IO 成本高。在高并发场景下，比如商品详情、用户信息、配置数据，如果每次都查 MySQL，数据库很容易成为瓶颈。
Redis 基于内存，读写速度是毫秒甚至微秒级，可以极大提升系统吞吐量。

第二，并发和分布式问题
Redis 提供了很多天然支持并发的能力，比如：

• 原子操作（INCR、SETNX）
• 分布式锁
• 高效的数据结构（Set、ZSet）

所以在实际项目中，Redis 常用来：

• 做缓存
• 做计数器
• 做分布式锁
• 做排行榜、限流、消息队列等

👉 面试官想听的是：
Redis 不只是缓存，而是“高并发场景的基础设施”

---

2️⃣ Redis 为什么这么快？

不要只说“因为在内存里”

你可以从 4 个层面展开：

1️⃣ 内存存储
Redis 的数据全部存放在内存中，避免了磁盘 IO，这是性能提升的最根本原因。

2️⃣ 单线程模型（命令执行）
Redis 的核心命令执行是单线程的：

• 避免了多线程加锁
• 没有线程切换的上下文开销

很多人误解“单线程=慢”，但 Redis 的瓶颈从来不是 CPU，而是 IO。

3️⃣ IO 多路复用
Redis 使用 epoll / kqueue 等 IO 多路复用技术，一个线程可以同时处理成千上万的连接请求，不会阻塞。

4️⃣ 高效的数据结构
Redis 内部不是简单的 HashMap，而是针对不同场景设计了：

• SDS（简单动态字符串）
• QuickList
• SkipList
• ZipList（新版本已优化）

👉 一句话总结给面试官：
Redis 快是“内存 + 非阻塞 IO + 单线程无锁 + 数据结构优化”的综合结果

---

3️⃣ Redis 是单线程的吗？

这是一个非常经典的“陷阱题”

正确、完整的说法是：

• Redis 命令执行是单线程的
• Redis 网络 IO 在 6.0 以后是多线程的
• 数据读写和逻辑处理仍然是单线程

为什么 Redis 不用多线程执行命令？

• 单线程已经足够快
• 多线程反而会引入锁竞争
• Redis 的瓶颈通常在网络或内存，而不是 CPU

👉 面试官继续追问你时，你可以补一句：

Redis 的设计目标是“用最简单的模型，换取最稳定的性能”。

---

二、Redis 数据结构（必考 + 项目场景）

---

4️⃣ Redis 支持哪些数据结构？

你不要只“列”，要顺带说用途：

• String：最基础，缓存、计数器、锁
• Hash：对象存储
• List：队列、时间线
• Set：去重、关系
• ZSet：排序、排行榜

以及扩展结构：

• Bitmap：状态统计
• HyperLogLog：UV 统计
• Geo：地理位置
• Stream：消息队列

---

5️⃣ String 的底层和使用场景

详细说法：

String 是 Redis 最基础的数据结构，底层是 SDS（Simple Dynamic String），相比 C 的字符串：

• 支持自动扩容
• 记录长度，O(1) 获取
• 二进制安全

项目中 String 常用来：

• 缓存 JSON 数据
• 存验证码
• 存 Token
• 做计数器（INCR）

重点强调：

• INCR、DECR 是原子操作
• String 最大支持 512MB

---

6️⃣ Hash 为什么适合存对象？

Hash 是一个 key → field → value 的结构。

相比多个 String：

• 字段级别更新，不影响整体
• 内存更省
• 更符合对象模型

典型业务场景：

• 用户信息
• 商品信息
• 购物车（用户维度）

例如：

text
user:1001
  name -> tom
  age  -> 18

👉 面试官追问你时，你可以说：

当对象字段经常修改时，Hash 比 String + JSON 更合适。

---

7️⃣ List 的底层结构和应用场景

底层结构：

• Redis 早期用 ZipList + LinkedList
• 现在统一用 QuickList
  • 双向链表 + 压缩列表
  • 在性能和内存之间平衡

常见场景：

• 消息队列（LPUSH + RPOP）
• 最新消息列表
• 时间线（朋友圈、动态）

注意点：

• List 是有序、可重复
• 可以阻塞（BLPOP）

---

8️⃣ Set 的特点和应用

Set 是 无序、去重集合。

常用场景：

• 点赞用户集合
• 关注 / 粉丝
• 抽奖去重

优势：

• 去重天然支持
• 支持交集、并集、差集

---

9️⃣ ZSet 为什么适合排行榜？

ZSet 是 Redis 非常有代表性的结构：

• member + score
• score 决定排序
• member 唯一

为什么适合排行榜？

• 自动排序
• 支持按排名查询
• 支持范围查询

典型场景：

• 积分榜
• 热度榜
• 延迟队列（score = 时间戳）

---

三、缓存设计（Redis 面试核心）

---

🔟 Redis 缓存的经典模式（Cache Aside）

这是面试必讲模式

读流程：

1. 先查 Redis
2. Redis 没有 → 查 DB
3. 写入 Redis

写流程：

1. 更新数据库
2. 删除缓存

👉 为什么不是更新缓存？

• 更新缓存可能失败
• 删除缓存简单可靠

---

1️⃣1️⃣ 缓存穿透是什么？

定义：

• 查询一个数据库中也不存在的数据
• 每次都打到数据库

解决方案：

1. 缓存空值（短 TTL）
2. 布隆过滤器

布隆过滤器原理：

• 位数组 + 多个 hash
• 判断“可能存在 / 一定不存在”
• 允许误判，不允许漏判

---

1️⃣2️⃣ 缓存击穿是什么？

定义：

• 热点 key 过期
• 大量并发请求同时打 DB

解决方案：

• 互斥锁
• 永不过期 + 异步更新

---

1️⃣3️⃣ 缓存雪崩是什么？

定义：

• 大量 key 同时过期
• 系统瞬间崩溃

解决方案：

• 过期时间随机化
• 限流
• 多级缓存

---

四、Redis 过期与淘汰（必考）

---

1️⃣4️⃣ Redis 的过期策略

Redis 使用 两种方式结合：

• 惰性删除：访问时检查
• 定期删除：后台随机扫描

👉 Redis 不会一次性扫描全部 key，是为了避免阻塞主线程。

---

1️⃣5️⃣ Redis 内存淘汰策略

当内存满了：

• noeviction：不删除，直接报错
• allkeys-lru：最近最少使用
• allkeys-lfu：使用频率最低

👉 实际生产最常用：allkeys-lru / lfu

---

五、Redis 持久化（必考）

---

1️⃣6️⃣ Redis 为什么要持久化？

因为 Redis 是内存数据库：

• 进程挂了
• 机器重启
• 数据会丢

持久化用于 数据恢复。

---

1️⃣7️⃣ RDB 的原理和特点

• 定期生成内存快照
• 文件小、恢复快
• 可能丢失最近一段数据

适合：

• 备份
• 快速恢复

---

1️⃣8️⃣ AOF 的原理和特点

• 记录写命令
• 数据更安全
• 文件大

AOF 刷盘策略：

• always
• everysec（最常用）
• no

---

1️⃣9️⃣ RDB + AOF 如何选？

标准答案：

生产环境一般同时开启 RDB + AOF。

---

六、Redis 高可用（必考）

---

2️⃣0️⃣ Redis 主从复制原理

流程：

1. 从库发送 sync
2. 主库生成 RDB
3. 发送 RDB + 增量命令

作用：

• 数据备份
• 读写分离
• 高可用基础

---

2️⃣1️⃣ Sentinel 是干嘛的？

Sentinel 解决三个问题：

• 监控
• 故障转移
• 通知

👉 Sentinel 本身不存数据。

---

2️⃣2️⃣ Redis Cluster 是什么？

Redis Cluster 解决：

• 数据分片
• 高可用

通过 16384 个 slot 分配数据。

---

2️⃣3️⃣ Redis Cluster 的限制

• 多 key 操作需同 slot
• 不支持多 DB
• Lua 脚本受限

---

七、Redis 分布式锁（必考）

---

2️⃣4️⃣ Redis 如何实现分布式锁？

text
SET lock value NX EX 10

核心要点：

• 原子性
• 过期时间
• value 唯一

---

2️⃣5️⃣ 分布式锁的常见坑

• 锁提前过期
• 误删别人的锁

---

2️⃣6️⃣ 如何解决误删？

• value 使用 UUID
• Lua 脚本原子删除

---

2️⃣7️⃣ 为什么推荐 Redisson？

• 可重入锁
• 自动续期
• 实现成熟

---

八、Redis 和 MySQL 一致性（高频）

---

2️⃣8️⃣ Redis 和数据库如何保证一致性？

结论先行：

• 强一致很难
• 实际追求最终一致

常见方案：

• 先更新 DB
• 再删缓存
• 异步补偿

---

九、Redis 为什么不能当数据库用（加分）

---

2️⃣9️⃣ Redis 的局限性

• 内存成本高
• 持久化不是强一致
• 不支持复杂查询
• 事务能力弱

---

🔚 最后给你一句“面试总结话术”

Redis 本质是一个高性能的内存数据结构服务器，在项目中主要用于缓存和高并发控制。使用时重点考虑缓存一致性、过期策略、高可用和持久化方案，而不是简单把 Redis 当成数据库来用。

---

如果你愿意，下一步我可以：

• 🔥 把每一题写成“逐字面试口述稿”
• 🔥 Redis + MySQL + 事务一致性综合面试实战
• 🔥 模拟面试：我问 Redis，你现场答

你可以直接说一句：
👉 “把 Redis 第 X 部分写成逐字面试回答稿”

可以。我下面按“面试能讲 1–2 分钟”的标准，把 Redis 的核心高频点讲得更细：每个点都包含 是什么 → 为什么 → 怎么用 → 常见坑/追问。
（内容会很长，但你要的就是“别太简洁”。）

---

1）Redis 是什么？它在项目里到底解决什么问题？

是什么
Redis 是一个内存中的 Key-Value 数据结构服务器。很多人把它叫“缓存”，但它更像一个“高性能并发组件”，因为它不只存字符串，还提供 Set/ZSet/Hash 等结构，以及原子操作、过期、发布订阅等能力。

为什么用（面试要讲清楚动机）
项目用 Redis 通常解决两类矛盾：

1. 性能矛盾：MySQL 读写靠磁盘（哪怕有 buffer pool），在热点读、突发流量下容易成为瓶颈。Redis 内存访问 + 简单协议，延迟低、吞吐高。
2. 并发矛盾：一些“高并发下很难在 DB 上优雅实现”的能力（计数、限流、锁、排行榜、集合运算）Redis 天然更合适。

怎么用（举业务例子）

• 商品详情缓存（读多写少）
• 验证码、短信防刷（TTL + 原子计数）
• 点赞/关注（Set）
• 排行榜（ZSet）
• 防重复提交/分布式锁（SET NX EX + Lua）

常见坑 / 追问

• Redis 不是万能：一致性、持久化强度、内存成本、复杂查询都有限
• 面试官会追问：缓存一致性怎么保证？穿透/击穿/雪崩怎么处理？

---

2）Redis 为什么快？别只说“内存”，要讲完整链路

是什么
Redis 的“快”来自一套整体设计，不是某一个点。

为什么快（4层）

1. 内存存储：避免磁盘 IO，这是根本。
2. 单线程执行命令：命令执行路径单线程，避免多线程锁竞争、上下文切换；很多情况下反而更稳更快。
3. IO 多路复用：用 epoll/kqueue 让一个线程处理海量连接的读写事件（网络并发高）。
4. 数据结构优化：比如 SDS、QuickList、压缩结构等，针对不同长度/类型做了空间和时间的平衡。

怎么用（面试可举）
你可以说：“Redis 的瓶颈通常不是 CPU，而是网络和内存带宽，所以单线程执行模型在工程上很合理。”

追问/坑

• “单线程会不会被慢命令阻塞？”会。比如 KEYS *、大范围 LRANGE、大 HGETALL 都可能阻塞事件循环。生产要避免。
• “Redis 6.0 不是多线程了吗？”——网络 IO 多线程，命令执行主流程仍单线程。

---

3）Redis 真的是单线程吗？（陷阱题）

正确回答结构

• Redis 命令执行：主要是单线程（核心逻辑单线程）
• Redis 网络 IO：6.0+ 支持多线程处理网络读写（可配置），但执行命令仍单线程
• 另外：后台也有线程做 AOF 重写、RDB 保存等

为什么这么设计

• 单线程减少锁和线程切换，代码简单，性能稳定
• Redis 的主要耗时往往是网络/内存，而不是 CPU
• 一旦多线程执行命令，需要复杂锁管理，收益未必大

追问点

• “那 Redis 怎么利用多核？”：多实例（多进程）、分片（Cluster）、IO 线程等。

---

4）五大数据结构：不止会背，还要会“为什么选它”

下面每个结构我都给你“怎么讲 + 业务落地 + 注意点”。

---

4.1 String（最常用）——缓存/验证码/计数/锁

是什么
Redis 的 String 是二进制安全的字符串，底层是 SDS（简单动态字符串），会记录长度，扩容策略更工程化。

为什么选 String

• 最通用：你可以存 JSON、token、验证码、配置、简单对象序列化
• 支持原子自增 INCR/INCRBY，天然适合计数器
• 支持 SET NX EX，可用来做锁

怎么用（业务例）

• 验证码：code:phone -> 1234，TTL=60s
• 计数器：阅读量 INCR article:view:1
• 分布式锁：SET lock:order:1 uuid NX EX 10

常见坑/追问

• 大 value 会影响性能（网络传输、内存复制、持久化成本）
• 计数器落库策略：通常 Redis 累计、定时批量刷回 DB（避免频繁写库）

---

4.2 Hash（对象结构）——用户信息/购物车/商品字段

是什么
Hash 类似 key -> (field -> value) 的小字典。

为什么选 Hash

• 存对象时比 JSON 更灵活：可以只更新某个字段
• 相比为每个字段单独建 key，更省 key 数、也更好管理

业务例

• 用户信息：user:1001 {name:tom, age:18}
• 购物车：cart:uid {sku1:2, sku2:5}，增减直接 HINCRBY

坑/追问

• 面试官可能问：Hash 很大怎么办？
  • 一个 Hash 如果 field 非常多，会带来 rehash、遍历成本；可按业务拆分 key（例如按店铺拆购物车）
• “Hash 比 String(JSON) 一定更省吗？”：不绝对，小对象时 Redis 有压缩结构优化，但要结合字段数量与访问模式。

---

4.3 List（队列/时间线）——消息队列、最新列表

是什么
List 是有序可重复序列，常用 LPUSH/RPOP 或 RPUSH/LPOP 实现队列。底层是 QuickList（链表+压缩节点）。

为什么选 List

• 队列语义简单
• 支持阻塞弹出：BLPOP/BRPOP，适合简易任务队列

业务例

• 任务队列：生产者 LPUSH queue job，消费者 BRPOP queue 0
• 最新 N 条记录：LPUSH timeline msg + LTRIM timeline 0 99

坑/追问

• List 做 MQ 的缺点：
  • 没有天然 ACK/重试/消费组（消费者挂了消息可能丢或卡）
  • 高可靠场景更推荐 Stream、Kafka、RabbitMQ
• 面试官追问：如何避免队列积压？
  • 消费者水平扩展、分 key 分队列、监控长度、降级丢弃低优先级任务等

---

4.4 Set（无序去重集合）——点赞/关注/抽奖/去重

是什么
Set 是无序、元素唯一的集合。

为什么选 Set

• 去重天然支持
• 支持集合运算：交集/并集/差集（社交关系、共同关注等）

业务例

• 点赞：SADD like:post:1 uid，取消 SREM，是否点赞 SISMEMBER
• 抽奖：把参与用户放 Set，SRANDMEMBER 或 SPOP

坑/追问

• 大集合 SMEMBERS 一次取全量会阻塞，生产要分页或用 SSCAN
• 共同好友：SINTER 可能跨大量数据，注意成本与超时

---

4.5 ZSet（有序集合）——排行榜/延迟队列/热度

是什么
ZSet = Set + score，可按 score 排序。常见底层是跳表（SkipList）+ 哈希结构组合。

为什么选 ZSet

• 排序能力强
• 支持按排名、按 score 范围查询

业务例

• 排行榜：ZINCRBY rank 10 user1，ZREVRANGE rank 0 9 WITHSCORES
• 延迟队列：score=触发时间戳，轮询 ZRANGEBYSCORE 取到期任务

坑/追问

• 延迟队列要注意“并发取任务”一致性：通常用 Lua 原子“取+删”，避免重复消费
• 热点榜要注意“热 key”：某个榜太热会集中到单节点（Cluster 场景也会是热 slot）

---

5）缓存模式（Cache Aside）怎么讲清楚？面试官最爱问

是什么
Cache Aside（旁路缓存）是最常见的缓存模式：应用自己控制“读写缓存的时机”。

读流程（必须会讲）

1. 先查 Redis
2. 未命中 → 查 MySQL
3. 写入 Redis（设置 TTL），返回

写流程（重点讲删除）
通常是：先更新 DB，再删除缓存（而不是更新缓存）

为什么写操作是“删缓存”更好？

• 更新缓存可能失败、还可能写入旧值
• 删除缓存更简单可靠，下一次读会回源 DB 再回填缓存
• 缓存是“加速层”，数据库才是事实源

坑：删缓存失败怎么办？
你要能回答：

• 重试（本地重试/任务重试）
• 记录失败事件异步补偿（消息队列/延迟队列）
• 关键业务读主库兜底

---

6）缓存三大问题：穿透 / 击穿 / 雪崩（必须能讲透）

6.1 缓存穿透（查不存在的数据）

现象
恶意或异常请求大量访问不存在的 key，Redis 永远 miss，每次都打 MySQL。

解决方案（两类）

1. 缓存空值：DB 不存在也写一个占位（TTL 短一点，比如 1~5 分钟）
2. 布隆过滤器：先判断 key 是否“可能存在”，若一定不存在直接拦截

布隆过滤器怎么讲（要点）

• 位数组 + 多个 hash
• 特点：可能误判存在，但不会误判不存在
• 适合：海量 key 的存在性判断（如商品 id、用户 id）

---

6.2 缓存击穿（热点 key 过期瞬间）

现象
一个热点 key TTL 到期，大量并发同时 miss，然后同时打 DB，DB 被打爆。

解决（两类）

1. 互斥锁：同一时刻只允许一个线程回源 DB，其他线程等待/快速失败
2. 热点永不过期 + 异步更新：后台线程刷新缓存，用户请求永远命中

面试官追问：互斥锁用什么实现？

• 本地锁（单机）
• Redis 分布式锁（多机）
• 或者用 “singleflight” 之类的合并请求思想

---

6.3 缓存雪崩（大量 key 同时过期）

现象
同一批 key 设置了相近 TTL，在某一时刻集中失效，造成 DB 压力洪峰。

解决思路

• TTL 加随机值（比如 30min + 0~5min）让失效时间分散
• 多级缓存（本地 Caffeine + Redis）
• 限流降级（宁可返回旧数据/默认值，也别打爆 DB）

---

7）Redis 过期删除机制：为什么不是“到点立刻删”？

你这样讲最稳：

Redis 过期 key 删除采取 惰性删除 + 定期删除 的组合：

1. 惰性删除：访问 key 时，发现过期才删除
   优点：省 CPU；缺点：如果 key 不再访问，可能一直占内存

2. 定期删除：后台线程周期性随机扫描部分 key，删除已过期的
   优点：控制内存；缺点：不能太频繁，避免影响主线程

追问：为什么不全量扫描？
全量扫描是 O(N)，N 大时会阻塞服务，影响延迟。

---

8）内存淘汰策略：内存满了到底发生什么？

重点要讲“场景选择”
maxmemory 达到阈值后，写入操作会触发淘汰策略：

• noeviction：不淘汰，写入直接报错（适合强业务不允许丢缓存？通常不选）
• allkeys-lru：对所有 key 使用 LRU 淘汰（常用）
• allkeys-lfu：对所有 key 使用 LFU 淘汰（热点更稳定，越来越常用）
• volatile-xxx：只淘汰设置了过期时间的 key（如果你大量 key 没 TTL，会很危险）

LRU vs LFU 怎么讲

• LRU：淘汰“最近最少使用”的 key，适合一般场景
• LFU：淘汰“访问频率最低”的 key，对热点更友好（不会因为短暂冷却就被淘汰）

---

9）持久化：RDB/AOF 到底怎么选？会丢数据吗？

9.1 RDB（快照）

是什么
把某一时刻的内存数据做成快照文件（dump.rdb）。

优点

• 文件紧凑，恢复快
• 适合备份、快速恢复

缺点

• 两次快照之间的数据可能丢（取决于配置频率）

追问：RDB 生成会阻塞吗？
通常用 fork 子进程生成快照，主进程继续处理请求，但 fork 在内存很大时可能有瞬时抖动。

---

9.2 AOF（追加日志）

是什么
把每条写命令追加写到 AOF 文件，重启时回放恢复。

刷盘策略（面试一定会问）

• always：每条命令都刷盘，最安全最慢
• everysec：每秒刷盘一次，最常用（性能与安全折中）
• no：让 OS 决定，性能最好但风险高

AOF 重写是什么？为什么需要？
AOF 会越来越大，所以 Redis 会把“多条写命令”压缩成“等价的最小命令集”（rewrite），减少文件体积。

---

9.3 生产怎么选？

你可以这样说：

生产通常会开启 AOF（everysec）保证较小的数据丢失窗口，同时配合 RDB 做冷备和快速恢复。具体看业务能否容忍 1 秒数据丢失。

---

10）主从复制：怎么同步？全量和增量是什么？

是什么
Redis 主从用于：读写分离、数据冗余、做高可用基础。

同步过程（讲清楚三步）

1. 从节点发起同步请求
2. 主节点进行全量同步：生成 RDB 发给从节点
3. 同步期间主节点把新写命令写入 replication buffer，之后进行增量同步（命令传播）

追问：主从一致性强吗？

• Redis 主从是异步复制（默认），存在延迟
• 读写分离时要考虑：刚写的数据从库可能读不到（读主/半同步策略/业务容忍）

---

11）Sentinel（哨兵）：到底解决什么？怎么选主？

是什么
Sentinel 是 Redis 的高可用组件，负责：

• 监控 master/slave
• 自动故障转移（failover）
• 通知客户端新的 master

怎么判断主挂了？

• 主观下线：某个 Sentinel 认为 master 不可达
• 客观下线：多个 Sentinel 达成一致（投票超过阈值）

failover 怎么做（概念流程）

1. Sentinel 选出 leader
2. leader 在从库中选一个最合适的（复制偏移量最大、延迟小）提升为 master
3. 其他从库改为复制新 master
4. 通知客户端更新地址

追问：Sentinel 本身要几个？
一般至少 3 个，保证投票多数派。

---

12）Cluster（集群）：分片怎么做？CROSSSLOT 为啥报错？

是什么
Redis Cluster = 分片 + 高可用：

• 数据分散到多个 master（水平扩展）
• 每个 master 有 slave 保障可用性

核心：slot（槽）机制

• 16384 个槽
• key 通过 CRC16 映射到某个槽
• 槽归属于某个 master

CROSSSLOT 报错原因
多 key 操作（MGET、事务、Lua、SUNION…）要求 key 在同一个 slot，否则无法在单节点完成。

怎么解决：Hash Tag
用 {} 指定 hash 的片段：

• order:{1001}:info
• order:{1001}:pay
  这样 {1001} 相同，会落到同一个 slot。

追问：Cluster 为啥不支持 SELECT 多库？
分片下多 DB 语义复杂，Cluster 模式基本只用 db0。

---

13）分布式锁：用 Redis 怎么实现？为什么必须 Lua？

13.1 最基本实现

标准写法：

• 加锁：SET lock:key uuid NX EX 10
  • NX：不存在才设置
  • EX：自动过期避免死锁
  • uuid：锁持有者标识

为什么要 uuid？
避免误删别人的锁：A 的锁过期后被 B 获取，A 业务结束后 DEL 可能把 B 的锁删掉。

13.2 为什么释放锁要用 Lua？

因为“判断 + 删除”必须原子：

1. GET lock 是否等于自己的 uuid
2. 是才 DEL

如果用两条命令，中间可能被抢锁导致误删。Lua 能把两步变为一条原子脚本执行。

13.3 追问：锁过期了但业务没做完怎么办？

两种回答思路（很加分）：

• 业务侧：估算合理 TTL + 续期机制
• 工程侧：用 Redisson 看门狗自动续期（只要线程还活着就续）

---

14）Redis 事务（MULTI/EXEC）：能回滚吗？靠不靠谱？

是什么
Redis 事务是“命令队列化”：

• MULTI：开始事务
• 命令入队
• EXEC：一次性执行

关键点（面试必须说清）

• Redis 事务不支持回滚
• EXEC 执行时，命令是顺序执行的；中间失败不会撤销之前成功的命令

所以它适合什么？
适合“需要一次性顺序执行的一组命令”，但不适合强一致回滚语义。真正需要原子性更推荐 Lua。

---

15）Pipeline：为什么能提速？什么时候反而不适合？

是什么
Pipeline 把多条命令一次性发送，减少网络 RTT（来回次数），吞吐会提升。

为什么能提速
Redis 处理命令很快，很多时候慢在网络往返。Pipeline 把 N 次 RTT 变成 1 次 RTT。

坑/追问

• Pipeline 不是事务：不保证原子
• Pipeline 太大：单次返回数据大，会占内存、产生延迟尖刺
• Cluster：Pipeline 可能分发到多个节点，收益取决于 key 分布

---

16）Stream：为什么说它更像“Redis 自带 MQ”？

是什么
Redis Stream 是更现代的消息队列结构，支持：

• 消费组
• ACK
• pending list（未确认消息）
• 重投递

相比 List 做 MQ
List 缺少消费组、ACK、可靠投递机制；Stream 更适合“需要可靠消费”的场景。

追问：那为什么还用 Kafka？
Stream 适合轻量、低门槛；Kafka 更适合海量数据、跨机房、强吞吐、长期堆积等场景。

---

17）缓存一致性：Redis 和 MySQL 怎么做到“相对靠谱”？

核心结论
绝大多数业务做的是最终一致，强一致成本很高。

经典写策略：先写 DB，再删缓存

• 更新 DB 成功后删除缓存
• 读请求 miss 后回源 DB 再回填

删缓存失败怎么办（必须能接追问）

• 重试（本地重试/异步任务）
• 消息队列补偿（记录需要删的 key）
• 关键业务：短时间读主库兜底

为什么不先删缓存再写 DB？
会有并发窗口：删缓存后、写 DB 前，另一个线程读 miss 回源拿到旧数据并回填，导致脏缓存。

---

18）如何避免 Redis 线上“卡顿/延迟飙升”？

面试官问“线上问题排查”时很常见，你可以从这些点讲：

• 避免 O(N) 命令：KEYS *、大 SMEMBERS、大 LRANGE 0 -1
• 大 key / 热 key：
  • 大 key 导致序列化、网络、删除都慢
  • 热 key 造成单点压力，Cluster 下也可能是热 slot
• 持久化抖动：RDB fork、AOF rewrite 时可能导致延迟尖刺
• 内存碎片：高频写删会碎片化，关注 mem_fragmentation_ratio
• 连接数与慢日志：SLOWLOG、INFO、LATENCY DOCTOR

---

19）大 Key / 热 Key：怎么发现？怎么治理？（非常加分）

大 key 是什么
value 很大（大字符串、大 Hash、大 List/Set/ZSet）导致：

• 读写慢
• 删除慢（阻塞）
• 持久化成本高

热 key 是什么
访问频率极高的 key 导致某个节点 CPU/带宽打满。

治理思路

• 大 key：拆分（分片字段、分页存储）、异步删除（UNLINK）、压缩/只存必要字段
• 热 key：本地缓存、热点多副本、随机前缀、应用层分散读、CDN（如果是静态）

---

20）你可以用来“收尾”的面试总结话术

Redis 在项目里核心价值是：用内存和高效数据结构换取高并发性能。真正工程落地时，要重点考虑缓存模式、三大缓存问题、过期淘汰策略、持久化与高可用，以及和数据库的一致性方案；另外要关注大 key/热 key 和慢命令带来的延迟抖动。

---

你接下来怎么用这份内容（不问你问题，直接给建议）

• 如果你要突击：优先背 1、2、5、6、9、10、13、17、18、19（这些是最容易被追问的）
• 如果你要“能讲出项目感”：每题都加一句“我在项目里会怎么做 / 会怎么配置 / 会怎么兜底”

---

如果你还想更“口述稿化”（真正逐字稿），我可以把上面每一条改成：
“面试官问 → 你完整回答（约 60–120 秒）→ 面试官追问 → 你补充” 的格式，一条条给你。你想先从哪块开始：** 缓存一致性**、高可用（Sentinel/Cluster）、还是分布式锁？