redis
Redis 高级开发面试与生产实践笔记
目标:不是把 Redis 的知识点堆在一起,而是建立一套能够用于面试回答、项目设计、线上排查的思维框架。
建议复习方式:先看每章的“核心结论”,再看“为什么”,最后用“面试追问”自测。
一、Redis 为什么快?
1. 面试母问题
面试官:Redis 为什么性能这么高?
可以按下面几个点回答:
-
数据主要存储在内存中
- 避免了大量磁盘随机 I/O。
- 内存访问速度远高于磁盘。
-
数据结构高效
- Redis 并不是简单的
HashMap。 - 针对不同业务提供 String、Hash、List、Set、ZSet 等结构。
- 底层根据数据特点选择不同编码/实现。
- Redis 并不是简单的
-
I/O 多路复用
- 一个 Redis 进程可以管理大量客户端连接。
- Linux 上通常利用
epoll等机制。 - Redis 不需要为每个连接创建一个线程。
-
核心命令执行开销低
- 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”向“能做后端架构和线上问题排查”迈进的关键一步。

浙公网安备 33010602011771号