redis

Redis 高级开发面试与生产实践笔记

目标:不是把 Redis 的知识点堆在一起,而是建立一套能够用于面试回答、项目设计、线上排查的思维框架。

建议复习方式:先看每章的“核心结论”,再看“为什么”,最后用“面试追问”自测。


一、Redis 为什么快?

1. 面试母问题

面试官:Redis 为什么性能这么高?

可以按下面几个点回答:

  1. 数据主要存储在内存中

    • 避免了大量磁盘随机 I/O。
    • 内存访问速度远高于磁盘。
  2. 数据结构高效

    • Redis 并不是简单的 HashMap。
    • 针对不同业务提供 String、Hash、List、Set、ZSet 等结构。
    • 底层根据数据特点选择不同编码/实现。
  3. I/O 多路复用

    • 一个 Redis 进程可以管理大量客户端连接。
    • Linux 上通常利用 epoll 等机制。
    • Redis 不需要为每个连接创建一个线程。
  4. 核心命令执行开销低

    • Redis 的核心数据操作长期采用单线程事件循环模型。
    • 避免大量线程切换和锁竞争。
    • 新版本 Redis 可以使用多线程处理部分网络 I/O,但核心命令执行仍然保持串行处理模型。

Redis 请求大致流程

客户端
  ↓
TCP连接
  ↓
I/O多路复用
  ↓
事件循环
  ↓
读取请求
  ↓
解析命令
  ↓
查找命令
  ↓
执行命令
  ↓
操作数据结构
  ↓
生成响应
  ↓
TCP返回
  ↓
客户端

最重要的理解

不要简单记成:

Redis 快 = 因为内存。

更准确的是:

内存 + 高效数据结构 + I/O 多路复用 + 低线程切换/锁竞争开销 + 简单高效的命令执行模型。


二、Redis 数据结构和底层实现

1. Redis 的五种常见逻辑数据类型

String
Hash
List
Set
ZSet

但是一个非常重要的概念是:

Redis 的逻辑数据类型,不等于底层物理数据结构。

Redis 会根据数据规模、元素类型等情况选择合适的底层编码。


2. 常见对应关系

Redis 类型 常见底层实现/编码 主要特点
String SDS 等 二进制安全、长度获取方便
Hash ListPack / HashTable 小数据节省内存,大数据保证访问效率
List QuickList + ListPack 在内存占用和访问效率之间折中
Set IntSet / HashTable 小整数集合可以节省大量内存
ZSet HashTable + SkipList 同时满足按成员查分值和范围/排名操作

具体底层编码会随 Redis 版本演进,因此面试时重点掌握“逻辑类型 → 为什么需要这种底层结构”,不要死背某个版本的内部类名。


3. String 为什么使用 SDS?

SDS 可以理解成 Redis 自己实现的字符串结构。

相比 C 字符串:

  • 可以直接记录长度;
  • 获取字符串长度不需要遍历;
  • 二进制安全;
  • 扩容策略更适合频繁修改;
  • 减少频繁内存分配。

所以 Redis String 不应该简单理解成 Java 中的 String。


4. Hash 为什么小数据和大数据可能使用不同结构?

小 Hash 如果直接使用完整 HashTable,会产生较多额外内存开销。

因此小数据可以使用紧凑型结构。

当数据量变大,对查询、插入等效率要求提高后,再使用 HashTable。

核心思想:

数据少
 ↓
优先节省内存

数据多
 ↓
优先保证操作效率

5. ZSet 为什么需要两套结构?

ZSet 是面试非常喜欢问的一个点。

例如:

userA -> 100
userB -> 90
userC -> 80

Redis 需要同时支持:

ZSCORE userA

快速找到 userA 的 score。

同时还要支持:

ZRANGE
ZREVRANGE
ZRANK

按照 score 排序、范围查询、排名。

因此 ZSet 需要兼顾:

HashTable
    ↓
member -> score
    ↓
快速定位某个成员

SkipList
    ↓
按照 score 排序
    ↓
范围查询 / 排名

为什么使用跳表?

跳表平均时间复杂度可以达到:

查询:O(logN)
插入:O(logN)
删除:O(logN)

而且实现相对简单,非常适合有序集合的范围操作。


三、Redis 在项目中怎么用?

1. 面试母问题

你们项目中 Redis 主要用来做什么?

不要一上来背:

缓存、分布式锁、限流、排行榜、Session……

应该从真实业务场景开始。

常见用途:

Redis
 ├── 缓存热点数据
 ├── 分布式锁
 ├── 计数器
 ├── 临时状态
 ├── 排行榜
 ├── 限流
 └── Session 等

2. 最常见:Cache Aside

读

请求
 ↓
Redis
 ↓
命中? ── 是 → 返回
 ↓ 否
MySQL
 ↓
写入Redis
 ↓
返回

写

常见做法:

更新MySQL
   ↓
删除Redis

而不是简单地认为:

更新MySQL
   ↓
更新Redis

原因是更新缓存容易引入更多并发一致性问题。


3. Key 设计

推荐:

业务:对象:ID

例如:

user:10001
order:10001
product:10001

不要随意设计成:

abc123
data001
test

Key 最好能够体现业务含义。


4. TTL

缓存一般需要设置 TTL。

原因:

  • 防止无效数据永久占用内存;
  • 避免 Redis 内存无限增长;
  • 给数据提供自然失效机制。

大量 Key 同时写入时,不建议所有 Key 使用完全相同的 TTL。

例如:

TTL = 3600 + random(0, 300)

避免大量 Key 同时过期形成缓存雪崩。


四、Redis 缓存常见问题

1. 缓存穿透

定义

请求查询一个根本不存在的数据。

请求
 ↓
Redis miss
 ↓
MySQL miss
 ↓
返回不存在

如果攻击者不断查询不存在的 ID:

Redis → 一直 miss
MySQL → 被不断打

解决

方案一:缓存空值

Redis:
user:999999 = null
TTL = 60s

方案二:Bloom Filter

先判断:

ID 是否可能存在?

如果 Bloom Filter 判断不存在,可以直接返回。

Bloom Filter 存在误判“可能存在”的情况,但不会把真实存在的数据判断成不存在。


五、缓存击穿、雪崩、热 Key、大 Key

这几个概念非常容易混。

问题 核心特征
穿透 查不存在的数据
击穿 一个热点 Key 过期,大量请求同时打数据库
雪崩 大量 Key 同时失效,或者缓存整体不可用
热 Key 一个 Key 被大量访问
大 Key 一个 Key 存储的数据量特别大

1. 缓存击穿

例如:

热门商品
 ↓
Redis中只有一个Key
 ↓
突然过期
 ↓
10000个请求同时miss
 ↓
10000个请求查询MySQL

常见解决方案:

  • 分布式锁;
  • 逻辑过期;
  • 热点数据预热;
  • 合理 TTL。

2. 缓存雪崩

例如:

10万个Key
 ↓
TTL全部设置3600秒
 ↓
3600秒附近同时过期
 ↓
大量请求同时访问MySQL

常见解决:

TTL随机化
+
缓存预热
+
Redis高可用
+
限流/降级

3. 热 Key

例如:

product:10001

一天中绝大多数请求都访问这个 Key。

Redis Cluster 中:

一个Key
 ↓
一个Slot
 ↓
一个Master

所以:

增加 Redis 节点,并不能自动把一个热 Key 的流量分散到多个节点。

解决思路:

拆 Key

例如:

product:10001:0
product:10001:1
product:10001:2
...

业务侧根据规则选择 Key。

也可以使用:

  • 本地缓存;
  • 热点数据复制;
  • 业务层分片。

4. 大 Key

大 Key 和热 Key 完全是两个维度。

热 Key:
访问次数多

大 Key:
数据量大

例如:

book:10001

里面存了整本小说几十 MB。

即使只有一个请求访问它,它也是大 Key。

大 Key 可能带来的问题:

  • 网络传输大;
  • Redis 处理时间增加;
  • Java 客户端需要更多内存;
  • 主从复制压力增加;
  • RDB/AOF 操作压力增加;
  • 删除大 Key 可能造成明显延迟。

更合理的设计:

book:10001:chapter:1
book:10001:chapter:2
book:10001:chapter:3
...

六、Redis 和 MySQL 数据一致性

1. 最重要的认识

Redis 和 MySQL 是两个独立系统,普通代码无法天然保证二者强一致。

所以不要把:

update MySQL
delete Redis

理解成“强一致”。

它只是常见的 Cache Aside 方案。


2. 为什么通常更新数据库后删除缓存?

例如:

MySQL = 20
Redis = 20

如果先删 Redis:

A:删除Redis
B:Redis miss
B:读取MySQL = 20
B:写入Redis = 20
A:更新MySQL = 21

最终:

MySQL = 21
Redis = 20

出现旧数据。


3. 常见方案

方案一:更新 DB → 删除 Cache

DB更新
 ↓
删除Redis

简单、常见。

但仍然存在极端并发窗口。


方案二:延迟双删

大致:

删除Redis
 ↓
更新DB
 ↓
等待一小段时间
 ↓
再次删除Redis

目的:

尽量消除并发读请求把旧数据重新写回 Redis 的情况。

但:

延迟双删不是强一致方案。


方案三:MQ / Binlog 最终一致

例如:

MySQL
 ↓
可靠消息
 ↓
RocketMQ
 ↓
消费者
 ↓
Redis

或者:

MySQL Binlog
 ↓
Canal等
 ↓
MQ
 ↓
Redis

适合对一致性要求更高、允许最终一致的场景。


七、MQ 最终一致性为什么还需要幂等?

这是一个非常重要的盲区。

假设:

MySQL更新成功
 ↓
发送MQ
 ↓
MQ发送成功
 ↓
Java进程突然挂了

此时:

消息已经成功

但程序可能还没来得及记录:

消息已发送

程序恢复后可能再次发送。

结果:

同一个业务消息
 ↓
RocketMQ
 ↓
消费两次

所以 MQ 系统一般需要接受:

至少一次投递(At-Least-Once)带来的重复消费。

解决方法:

消费幂等

例如使用业务唯一 ID:

messageId
businessId
orderId

数据库使用唯一约束,或者业务状态机天然保证幂等。

例如:

UPDATE orders
SET status = 'PAID'
WHERE id = ?
  AND status = 'UNPAID';

第一次:

UNPAID → PAID

第二次:

PAID → PAID

第二次不会再次执行实际业务变化。


八、Redis 持久化:RDB 和 AOF

1. RDB

RDB 本质:

某一个时间点的 Redis 数据快照。

例如:

12:00
 ↓
保存快照

Redis当前数据
 ↓
dump.rdb

优点:

  • 文件紧凑;
  • 恢复速度快;
  • 适合备份;
  • 对 Redis 正常请求影响相对较小。

缺点:

  • 是时间点快照;
  • 两次快照之间的数据可能丢失。

2. SAVE 和 BGSAVE

SAVE

Redis主线程
 ↓
SAVE
 ↓
生成RDB
 ↓
期间阻塞正常请求

所以生产环境一般不使用 SAVE 做日常持久化。

BGSAVE

Redis主进程
      │
      ├── 继续处理请求
      │
      └── fork()
            ↓
          子进程
            ↓
          生成RDB

3. fork 后是不是复制了一份完整 Redis 内存?

不是简单理解成:

fork → 立刻复制整个 Redis 内存。

Linux 会利用:

Copy-On-Write(COW)

初始时父子进程共享内存页:

Parent ──┐
         ├── Page A
Child  ──┘

如果父进程修改 Page A:

Parent → 修改
         ↓
       COW
         ↓
复制一份新的Page

因此:

BGSAVE 期间 Redis 写入越多,COW 产生的额外内存压力可能越大。

这也是为什么 Redis 内存规划不能把机器内存塞得太满。


九、AOF

AOF:

Append Only File,记录写命令。

例如:

SET user:1 Tom
SET user:2 Jack
DEL user:1

Redis 重启时重新执行这些命令恢复数据。


1. appendfsync

主要有:

always
everysec
no

always

每次写操作都尽可能同步刷盘。

特点:

数据安全性高
性能开销大

everysec

大约每秒刷一次。

特点:

性能和数据安全之间比较平衡

通常是常见选择。

no

由操作系统决定什么时候刷盘。

性能更好,但可靠性较弱。


十、AOF Rewrite

如果一直记录:

SET a 1
SET a 2
SET a 3
SET a 4

其实最终只需要:

SET a 4

所以 AOF Rewrite 的目标是:

根据当前内存中的最终状态,重新生成一份更精简的 AOF。

不是简单意义上的“压缩原来的 AOF”。


Rewrite 期间发生什么?

Redis主进程
   │
   ├── 继续处理写请求
   │
   └── 子进程执行Rewrite
              ↓
        生成新的AOF

主进程在 Rewrite 期间产生的新写命令需要继续保存。

最终把:

旧数据的精简结果
+
Rewrite期间新增写入

合并成新的 AOF。


十一、RDB vs AOF

对比 RDB AOF
本质 时间点快照 写命令日志
文件 更紧凑 通常更大
恢复 通常较快 通常需要重放
数据丢失窗口 取决于快照频率 取决于 fsync 策略
对写请求影响 BGSAVE + COW 持续追加 + Rewrite
适合 备份、快速恢复 更细粒度的数据持久化

最重要的不是背表格

面试时说:

RDB 关注“某个时间点的数据快照”,AOF 关注“写操作日志”。RDB 恢复快、文件紧凑,但快照之间存在数据丢失窗口;AOF 可以通过 fsync 策略控制持久化程度,但文件和恢复成本通常更高。


十二、Redis 主从复制

1. 为什么需要主从?

主要目的:

Master
  ↓
Replica

用于:

  • 数据冗余;
  • 故障转移;
  • 读扩展;
  • 提高高可用能力。

2. 第一次同步:全量同步

大致过程:

Replica
  ↓
PSYNC
  ↓
Master判断无法增量同步
  ↓
生成RDB
  ↓
发送RDB
  ↓
Replica加载RDB
  ↓
Master继续发送期间产生的新写命令
  ↓
Replica追平

3. 部分重同步

如果 Replica 只是短暂断开:

Master
 ↓
Replication Backlog

仍然保存着断开期间的一部分复制历史。

Replica 恢复后可以根据:

Replication ID
+
Offset

请求缺失的数据。

这样就不用重新发送整个 RDB。


十三、Redis Sentinel

Sentinel 主要解决:

监控
+
故障发现
+
自动故障转移
+
Master发现

例如:

Master
  │
  ├── Replica1
  └── Replica2

Sentinel1
Sentinel2
Sentinel3

1. SDOWN 和 ODOWN

SDOWN

某一个 Sentinel 自己认为:

Master 不可用。

ODOWN

多个 Sentinel 达成共识:

Master 确实不可用。

之后可以进入故障转移流程。


2. 故障转移

大致:

Master故障
 ↓
Sentinel发现
 ↓
Sentinel之间达成共识
 ↓
选举Leader Sentinel
 ↓
选择合适Replica
 ↓
提升Replica为新Master
 ↓
其他Replica重新复制新Master
 ↓
客户端重新发现Master

Replica 选择并不是简单理解成:

“谁 offset 最大谁就一定当 Master。”

还会综合复制状态、优先级等条件。


十四、脑裂

这是 Redis 高可用非常重要的面试点。

例如:

客户端
   │
   ↓
旧Master

网络发生分区

Sentinel侧
   ↓
认为旧Master挂了
   ↓
提升Replica
   ↓
新Master

但是:

旧Master实际上没死

它可能仍然接受客户端写入。

于是:

旧Master:写入A
新Master:写入B

形成两个 Master。


常见缓解配置

min-replicas-to-write 1
min-replicas-max-lag 10

含义可以理解为:

Master 只有在至少有一个健康、复制延迟不超过阈值的 Replica 时才允许继续写。

注意:

min-replicas-max-lag 是复制延迟/健康检查相关的时间阈值,不是“允许丢多少条数据”。

它可以降低脑裂风险,但不能让分布式系统变成绝对强一致。


十五、Redis Cluster

这里一定要区分:

Sentinel
    ↓
主要解决高可用 + 自动故障转移

Cluster
    ↓
主要解决数据分片 + 高可用

十六、Redis Cluster 的 16384 个 Slot

Redis Cluster 不直接:

key → node

而是:

key
 ↓
CRC16(key)
 ↓
% 16384
 ↓
Slot
 ↓
Master

例如:

keyA → Slot 100 → Master A
keyB → Slot 6000 → Master B
keyC → Slot 12000 → Master C

为什么是 16384?

它是 Redis Cluster 在:

节点管理成本
+
Slot数量
+
集群规模

之间做出的工程折中。

面试时不用过度纠结这个数字的历史细节。


十七、MOVED 和 ASK

MOVED

例如:

MOVED 5231 10.0.0.3:6379

含义:

这个 Slot 正式属于另一个节点。

客户端收到后:

更新Slot → Node映射
 ↓
以后直接访问正确节点

ASK

ASK 通常出现在 Slot 正在迁移过程中。

Slot正在从A迁移到B

某个 Key 可能已经迁移到 B,但 Slot 的正式归属还没有最终切换。

因此:

ASK

更偏向:

“这一次请求,请临时去另一个节点。”

而:

MOVED

是:

“这个 Slot 的正式归属已经变了。”


十八、Redis Cluster 多 Key 操作:一个容易踩坑的点

错误理解:

Redis Cluster 下 MGET 要求所有 Key 必须是同一个 Slot。

更准确的说法:

多 Key 操作要求这些 Key 最终由同一个 Cluster 节点处理。

因为:

Master A
 ├── Slot 0
 ├── Slot 100
 └── Slot 2000

如果:

key1 → Slot 100 → A
key2 → Slot 2000 → A

虽然 Slot 不一样,但是都在 Master A 上,因此可以由同一个节点处理。

如果:

key1 → Slot 100 → A
key2 → Slot 6000 → B

就会产生:

CROSSSLOT

十九、Hash Tag

如果希望相关 Key 一定进入同一个 Slot:

user:{100}:name
user:{100}:age
user:{100}:balance

Redis 会使用 {} 中的内容参与 Hash。

因此:

{100}

相同:

→ 相同Slot
→ 相同Master

这样可以支持一些多 Key 操作和 Lua/事务场景。

但不能滥用:

user:{all}:xxx

否则所有数据都集中到一个 Slot,形成热点。


二十、Redis 分片容量怎么设计?

不要面试时直接说:

500GB 数据就部署 5 台。

因为 Redis 节点数量至少要考虑:

数据容量
+
QPS
+
CPU
+
网络
+
持久化
+
高可用
+
增长空间

例如业务数据 300GB。

如果经过压测发现:

一个Master比较适合承载约100GB业务数据

那么可能规划:

Master A
Master B
Master C

+
Replica A
Replica B
Replica C

但这只是一个容量规划示例,不是固定公式。

尤其要预留:

  • Redis 数据结构额外开销;
  • 内存碎片;
  • BGSAVE/AOF Rewrite 的 COW;
  • 操作系统内存;
  • 数据增长;
  • 故障切换空间。

不要把一台 256GB ECS 的 220GB 都当成可以安全存 Redis 数据的空间。


二十一、Redis 分片为什么不能解决热 Key?

因为:

一个Key
 ↓
一个Hash Slot
 ↓
一个Master

即使:

3台Master
→
10台Master

这个 Key 仍然只能落在一个 Slot。

所以:

扩容解决的是整体容量/整体流量分布,不会自动解决单 Key 热点。

解决热 Key 需要:

Key拆分
+
本地缓存
+
热点复制
+
业务侧分片

二十二、Redis 大 Key

大 Key 的核心:

单个 Redis Key 对应的数据量过大。

例如:

book:10001
    ↓
几十MB小说内容

问题:

大Value
 ↓
网络传输大
 ↓
Redis处理成本增加
 ↓
Java内存增加
 ↓
主从复制压力增加
 ↓
RDB/AOF压力增加

更好的方式:

book:10001:chapter:1
book:10001:chapter:2
book:10001:chapter:3
...

二十三、Redis 分布式锁

1. 为什么需要 Redis 锁?

Java:

synchronized

只能保护:

JVM 1

如果部署:

ECS1 → Java实例1
ECS2 → Java实例2
ECS3 → Java实例3

三个 JVM 的锁互相不知道。

因此需要一个大家都能访问的共享协调系统。


二十四、Redis 分布式锁基本实现

SET lock:order:10001 unique-value NX EX 30

含义:

SET
    lock:order:10001
    unique-value
    NX
    EX 30

NX

只有 Key 不存在时才创建。

EX 30

30 秒后自动过期,避免进程死掉后锁永久存在。

unique-value

标识:

这个锁是谁加的。


二十五、为什么不能直接 GET + DEL?

反例:

if (redis.get("lock").equals(myValue)) {
    redis.del("lock");
}

问题:

A持有锁
 ↓
A TTL过期
 ↓
B重新获取锁
 ↓
A执行GET
 ↓
A看到的情况可能发生变化
 ↓
A执行DEL
 ↓
把B的锁删掉

GET 和 DEL 不是一个原子操作。


正确方式:Lua 原子删除

local value = redis.call('GET', KEYS[1])

if value == ARGV[1] then
    return redis.call('DEL', KEYS[1])
end

return 0

核心:

只有锁的持有者才能删除自己的锁,而且判断和删除必须原子执行。


二十六、Redis 分布式锁的 TTL 问题

假设:

锁TTL = 30秒
业务执行 = 60秒

那么:

0秒:A获取锁
30秒:锁自动过期
31秒:B获取锁
60秒:A还在执行

此时 A、B 同时执行临界区。

因此:

TTL 不是简单设置一个很大的数字就万事大吉。

需要根据业务执行时间设计。

对于需要自动续期的场景,可以使用类似 Redisson WatchDog 的机制。


二十七、Redis 锁的主从故障问题

还有一个非常重要的边界:

A
 ↓
Master
 ↓
Replica

如果:

A把锁写入Master
 ↓
还没复制到Replica
 ↓
Master宕机
 ↓
Replica提升为Master

那么新 Master 可能根本没有这把锁。

此时:

B → 新Master → 成功获取锁

所以:

普通 Redis SET NX EX 分布式锁并不是绝对强一致的锁。

对于要求极高的资源保护场景,还需要考虑:

  • 更严格的分布式锁方案;
  • Redlock 等算法;
  • Fencing Token;
  • 业务状态机/数据库条件更新。

重点是:

分布式锁到底需要多强的可靠性,要看业务。


二十八、Redis 线上问题怎么排查?

面试母问题

Redis 线上突然变慢,你怎么排查?

不要第一句话就说:

“看 CPU。”

正确思路:

先确认问题
 ↓
Redis真的慢吗?
 ↓
看Redis指标
 ↓
定位资源瓶颈
 ↓
定位具体命令/Key/节点
 ↓
结合Java/MySQL/网络继续排查

1. 先确认是不是 Redis

例如:

用户感觉接口变慢

不代表:

Redis一定变慢

可能是:

Java GC
MySQL慢SQL
网络
Redis
RocketMQ
ES

所以应该先看链路:

Nginx
 ↓
Java
 ↓
Redis
 ↓
MySQL

哪个环节耗时增加。


二十九、Redis 常见线上指标

重点关注:

CPU
Memory
OPS
Network
Connections
Latency
Slowlog
Replication
Key数量

CPU 高

可能:

  • 慢命令;
  • 大 Key;
  • 大量复杂操作;
  • Lua 脚本;
  • 大量连接/网络处理;
  • 持久化相关压力。

例如:

SLOWLOG GET

排查慢命令。


Memory 高

重点区分:

真实数据增长
vs
内存碎片
vs
临时内存/COW

可以关注:

used_memory
used_memory_rss

还需要排查:

  • TTL 是否合理;
  • Key 是否不断增长;
  • Big Key;
  • 是否出现大量临时 Key。

Big Key

可以使用:

MEMORY USAGE key

或者:

redis-cli --bigkeys

Hot Key

表现:

某个Key访问量异常高

可能导致:

某个Cluster节点CPU/OPS明显高于其他节点

Replica 延迟

需要结合:

Master写入压力
Replica CPU
网络
复制积压

判断为什么 Replica 没追上。


三十、一个非常重要的盲区:QPS ≠ 资源消耗

很多后端开发容易形成一个错误认知:

QPS 高 → CPU 高。

实际上不一定。

例如:

10000 QPS

情况 A

GET user:1
Value = 20 Bytes

可能非常轻。

情况 B

1000 QPS
HGETALL big:object
Value = 10MB

反而可能产生巨大:

CPU
+
网络
+
内存

因此真正应该考虑:

QPS
+
命令复杂度
+
数据量
+
Value大小
+
并发连接
+
网络流量
+
持久化

三十一、Redis + ECS:Redis 到底运行在哪里?

这是后端开发很容易模糊的一层。

Redis 本质上就是一个服务器程序。

最简单的情况:

ECS
┌─────────────────────────┐
│ Linux                   │
│                         │
│ redis-server :6379      │
│                         │
└─────────────────────────┘
             ↑
             │ TCP
             ↓
      Java Spring Boot

也就是说:

Redis 完全可以直接安装在 ECS 上运行。

例如:

Linux
 ↓
redis-server
 ↓
6379端口

Java:

Redis Client
 ↓
TCP
 ↓
ECS:6379

三十二、为什么还会有阿里云托管 Redis?

因为:

自己部署 Redis

不仅仅是:

yum install redis

生产环境还需要处理:

  • 主从;
  • Sentinel/Cluster;
  • 故障转移;
  • 备份;
  • 恢复;
  • 监控;
  • 扩容;
  • 升级;
  • 网络;
  • 安全;
  • 容灾;
  • 运维。

托管 Redis 的价值,本质上是:

把 Redis 的基础设施运维工作交给云平台。


三十三、Java 后端的中间件都能自己部署在 ECS 吗?

大多数情况下:

可以。

例如:

ECS
 ├── Redis
 ├── MySQL
 ├── RocketMQ
 ├── Elasticsearch
 ├── ZooKeeper
 ├── Kafka
 ├── RabbitMQ
 └── Nginx

技术上都可以自己部署。

但是生产环境一般不会把所有东西都塞进一台 ECS。

例如:

ECS-1
 └── Java

ECS-2
 └── Redis

ECS-3
 └── MySQL

ECS-4
 └── RocketMQ

ECS-5
 └── Elasticsearch

原因不是“不能一起装”,而是:

不同中间件对 CPU、内存、磁盘、网络的需求不同,放一起容易产生资源争抢。


三十四、后端代码到底怎么影响服务器指标?

这是一个非常重要的底层知识。

以后看到任何一段代码,都可以问四个问题:

① CPU
有没有大量计算?

② Memory
有没有大量数据/对象驻留内存?

③ Disk
有没有产生磁盘读写?

④ Network
有没有大量数据在机器之间传输?

建立这一条链:

Java代码
   ↓
JVM / 中间件
   ↓
Linux进程
   ↓
CPU / Memory / Disk / Network
   ↓
ECS监控指标

三十五、代码操作与 ECS 指标的对应关系

操作 主要影响 为什么
Java 大量循环、计算 CPU ↑ CPU 不断执行指令
JSON 序列化/反序列化 CPU ↑、内存 ↑ 需要计算转换,同时产生临时对象/字节数组
创建大量 Java 对象 内存 ↑、CPU ↑ 对象占 Heap,创建对象需要 CPU
List 保存几十万对象 内存 ↑ List 和对象都占 JVM Heap
大量 GC CPU ↑ GC 需要扫描、标记、复制/整理对象
Redis GET 小 Value 网络 ↑、CPU 少量 ↑ Redis读取后还要通过网络返回数据
Redis GET 大 Value 网络 ↑↑、Redis CPU ↑、Java内存 ↑ 大数据需要处理、传输、接收和创建对象
Redis HGETALL 大 Hash CPU ↑、网络 ↑、内存 ↑ Redis需要处理大量字段并返回大量结果
Redis KEYS * Redis CPU ↑↑ 需要遍历大量 Key
MySQL 全表扫描 CPU ↑、磁盘 I/O ↑ 需要扫描大量数据页并判断条件
MySQL INSERT/UPDATE CPU ↑、磁盘 I/O ↑ 修改数据并产生 Redo/Binlog 等持久化操作
MySQL 大查询 MySQL CPU ↑、网络 ↑、Java内存 ↑ 查询、返回、Java接收和保存大量数据
RocketMQ 发送消息 网络 ↑、Broker 磁盘 I/O ↑ Producer传输消息,Broker持久化 CommitLog
RocketMQ 消费消息 Java CPU ↑、网络 ↑ 拉消息、反序列化、执行业务
ES 大量写入 CPU ↑、磁盘 I/O ↑、网络 ↑ 解析文档、建立索引、写 Segment
ES 聚合查询 CPU ↑、内存 ↑ 聚合、排序等需要计算和中间结构
上传文件 网络 ↑↑、磁盘 I/O ↑ 文件需要网络传输并可能落盘
下载大文件 网络 ↑↑ ECS持续向客户端发送大量数据
大量日志 CPU ↑、磁盘 I/O ↑ 日志格式化需要CPU,写文件需要磁盘
Nginx 大量请求 CPU ↑、网络 ↑ 处理连接、HTTP协议和请求/响应

三十六、为什么一个简单 Java 接口可能同时影响四种资源?

例如:

List<User> users = userMapper.selectList(...);

看起来只是:

“查数据库。”

实际上链路可能是:

                MySQL
                  │
        ┌─────────┴─────────┐
        │                   │
      CPU                 Disk
        │                   │
        └─────────┬─────────┘
                  │
                网络
                  ↓
             Java ECS
                  │
        ┌─────────┼─────────┐
        │         │         │
       CPU      Memory    Network
        │         │         │
   对象映射      List       接收结果
        │         │
        └────┬────┘
             ↓
        JSON序列化
             │
       ┌─────┴─────┐
       CPU       Memory
       │            │
       ↓            ↓
   序列化计算    临时字符串
             │
             ↓
           网络
             ↓
           客户端

所以:

代码不是直接操作“CPU指标”,而是代码让 JVM、中间件和 Linux 产生资源消耗,最终反映到 ECS 的 CPU/内存/磁盘/网络指标上。


三十七、服务器四大资源的记忆方法

以后排查线上问题,可以先记住:

CPU
= 算

Memory
= 放

Disk
= 存

Network
= 传

进一步理解:

CPU

问:

有没有大量计算?

例如:

JSON
GC
循环
排序
聚合
复杂查询

Memory

问:

有没有大量数据需要暂时放在内存里?

例如:

Java对象
List
Redis数据
ES缓存
MySQL Buffer Pool

Disk

问:

有没有数据需要从磁盘读/写?

例如:

MySQL
Redis RDB/AOF
RocketMQ CommitLog
ES Segment
日志
文件

Network

问:

有没有大量数据在机器之间传输?

例如:

Java → Redis
Java → MySQL
Java → RocketMQ
Java → ES
客户端 → Nginx
文件上传/下载

三十八、最终形成一个“后端资源地图”

                         用户
                          │
                       Internet
                          │
                          ↓
                        Nginx
                          │
                          ↓
                    Java Spring Boot
                    /       |       \
                   /        |        \
                  ↓         ↓         ↓
               Redis      MySQL    RocketMQ
                  │          │         │
                  │          │         ↓
                  │          │      Consumer
                  │          │         │
                  │          │         ↓
                  │          │       业务
                  │          │
                  └────┬─────┘
                       ↓
                       ES

每一层都会消耗不同资源:

Java
 ├── CPU:业务计算、GC、JSON
 ├── Memory:JVM Heap、对象
 └── Network:调用各种中间件

Redis
 ├── Memory:数据
 ├── CPU:命令执行
 ├── Network:请求/响应
 └── Disk:RDB/AOF

MySQL
 ├── CPU:SQL执行
 ├── Memory:Buffer Pool
 ├── Disk:数据、Redo、Binlog
 └── Network:SQL结果

RocketMQ
 ├── CPU:消息处理
 ├── Memory:PageCache等
 ├── Disk:CommitLog
 └── Network:消息传输

ES
 ├── CPU:查询、聚合、索引
 ├── Memory:Heap/缓存
 ├── Disk:Segment
 └── Network:查询/写入

三十九、线上排查的最终思维框架

以后遇到:

“线上接口突然变慢。”

不要直接猜原因。

按照:

第一层:应用
    ↓
接口整体耗时是否增加?

第二层:链路
    ↓
Java / Redis / MySQL / MQ / ES
到底是哪一段慢?

第三层:服务器资源
    ↓
CPU
Memory
Disk I/O
Network

第四层:具体原因
    ↓
CPU高?
    → GC?
    → 慢命令?
    → SQL?
    → JSON?
    → ES聚合?

Memory高?
    → 大对象?
    → BigKey?
    → JVM Heap?
    → 缓存增长?
    → COW?

Disk高?
    → MySQL?
    → RDB/AOF?
    → MQ CommitLog?
    → ES Segment?
    → 日志?

Network高?
    → 大Key?
    → 大SQL结果?
    → MQ流量?
    → 文件传输?

四十、Redis 面试最终记忆版

如果只剩 5 分钟复习 Redis,抓住下面这张图:

Redis
│
├── 为什么快?
│   ├── 内存
│   ├── 高效数据结构
│   ├── I/O多路复用
│   └── 低线程切换/锁竞争
│
├── 数据结构
│   ├── String
│   ├── Hash
│   ├── List
│   ├── Set
│   └── ZSet
│
├── 缓存
│   ├── Cache Aside
│   ├── 穿透
│   ├── 击穿
│   ├── 雪崩
│   ├── 热Key
│   └── 大Key
│
├── 一致性
│   ├── DB → Delete Cache
│   ├── 延迟双删
│   ├── MQ
│   ├── Binlog
│   └── 最终一致性 + 幂等
│
├── 持久化
│   ├── RDB
│   ├── AOF
│   ├── BGSAVE
│   ├── COW
│   └── AOF Rewrite
│
├── 高可用
│   ├── Master / Replica
│   ├── Sentinel
│   ├── 故障转移
│   └── 脑裂
│
├── Cluster
│   ├── 16384 Slot
│   ├── CRC16
│   ├── MOVED
│   ├── ASK
│   ├── Hash Tag
│   ├── CROSSSLOT
│   ├── 热Key
│   └── 大Key
│
├── 分布式锁
│   ├── SET NX EX
│   ├── unique value
│   ├── Lua原子删除
│   ├── TTL
│   ├── 自动续期
│   └── 主从故障边界
│
└── 线上排查
    ├── CPU
    ├── Memory
    ├── Network
    ├── Disk
    ├── Slowlog
    ├── BigKey
    ├── HotKey
    └── Replication Lag

四十一、最重要的几个“盲区纠正”

这些是本次学习中特别值得记住的地方。

盲区 1:Redis 快不只是因为内存

应该记:

内存 + 数据结构 + I/O多路复用 + 低开销执行模型。


盲区 2:Redis Cluster 的 MGET 不是“必须同 Slot”

正确:

多 Key 操作需要最终由同一个 Cluster 节点处理。

不同 Slot 但同一个 Master,可以一起处理;跨 Master 才会 CROSSSLOT。


盲区 3:增加 Redis 节点不能自动解决热 Key

因为:

一个Key → 一个Slot → 一个Master

热 Key 必须从 Key 设计、缓存层或业务层解决。


盲区 4:RDB 的 fork 不是简单复制全部内存

正确理解:

fork
 ↓
父子进程共享内存页
 ↓
写入时COW
 ↓
产生额外内存

所以:

Redis 做 BGSAVE/AOF Rewrite 时,需要预留 COW 内存空间。


盲区 5:Redis + MySQL 的“更新DB再删缓存”不是强一致

它只是:

常见的 Cache Aside 实践。

更强的最终一致性需要可靠消息、重试、幂等等机制。


盲区 6:MQ 可靠消息不等于“发送一次就绝对不会丢”

真正的可靠最终一致性需要考虑:

消息发送
+
消息持久化
+
Broker复制
+
失败重试
+
消费重试
+
消费幂等
+
死信/补偿

盲区 7:QPS 高不一定 CPU 高

真正决定服务器压力的是:

QPS
+
单次操作成本
+
数据量
+
Value大小
+
并发
+
网络
+
持久化

盲区 8:Redis 是一个“程序”,ECS 是“机器”

可以这样理解:

ECS
 ↓
Linux
 ↓
redis-server进程
 ↓
6379端口
 ↓
Java通过TCP访问

云 Redis 只是把:

Redis进程
+
机器
+
高可用
+
备份
+
监控
+
运维

打包成了一个托管服务。


四十二、后续学习建议

Redis 这部分已经形成了比较完整的知识链。

下一步不要继续无限背 Redis API,而应该进入:

Redis知识
   ↓
Linux服务器指标
   ↓
JVM指标
   ↓
MySQL指标
   ↓
ES指标
   ↓
RocketMQ指标
   ↓
线上问题定位

最终达到:

看到一个 Java 接口,就能大致判断它会对 CPU、内存、磁盘、网络以及 Redis/MySQL/ES/MQ 产生什么影响。

这才是从“会用 Redis”向“能做后端架构和线上问题排查”迈进的关键一步。

posted @ 2026-09-28 10:56  zhangph  阅读(4)  评论(0)    收藏  举报