Redis 八股与工程(秋招速通版)¶
核心概念¶
(a) 🗂️ Redis 八股全景:从数据结构到高可用的一条主线¶
Redis 面试题有一条清晰的进阶路线:先懂「为什么快」与五种数据结构,再进入缓存场景(穿透 / 击穿 / 雪崩、一致性),然后是持久化与淘汰策略,最后是分布式锁与高可用(主从 / 哨兵 / 集群)。下图把九大主题串成一张地图。
(该图在 GitHub/VSCode + mermaid 插件中可渲染)
flowchart TB
Redis["🚀 Redis 八股全景"]
Redis --> DS["📦 五种数据结构 + 单线程为何快"]
Redis --> Cache["🧩 缓存三大问题<br/>穿透 / 击穿 / 雪崩"]
Cache --> Bloom["🌸 布隆过滤器"]
Redis --> Cons["🔄 缓存与数据库一致性"]
Redis --> Pers["💾 持久化:RDB vs AOF"]
Redis --> Exp["⏰ 过期删除与内存淘汰"]
Redis --> Lock["🔒 分布式锁(SETNX + Lua)"]
Redis --> HA["🏥 高可用与治理<br/>主从 / Sentinel / Cluster / 大 Key"]
- 📦 五种数据结构 + 单线程为何快:String(计数器 / 缓存)、List(消息队列)、Hash(对象)、Set(去重 / 共同关注)、ZSet(排行榜)各有底层实现。单线程快四问:纯内存访问、高效数据结构、IO 多路复用、避免上下文切换与锁竞争——但单线程也意味着一个慢命令会阻塞全局。
- 🧩 缓存三大问题:穿透(查不存在的 key 打穿到 DB)用空值缓存 / 布隆过滤器挡;击穿(热点 key 过期瞬间并发打 DB)用互斥锁 / 逻辑过期;雪崩(大量 key 同时过期)用随机过期时间 / 集群分散。三者的定义与方案对比表要能默写。
- 🌸 布隆过滤器:用多个哈希函数把 key 映射到位数组,能判断「一定不存在 / 可能存在」,以极小内存挡住穿透。要会讲误判率公式与「不能删除」的局限(可升级为计数布隆过滤器)。
- 🔄 缓存与数据库一致性:主流是 Cache-Aside(旁路缓存):读先查缓存、写先更 DB 再删缓存。难点在并发时序(先更 DB 还是先删缓存),常用延迟双删 / 订阅 binlog 异步更新兜底,接受「最终一致」而非强一致。
- 💾 持久化:RDB vs AOF:RDB 是定期全量快照、恢复快但可能丢数据;AOF 记写命令,appendfsync 三种策略在性能与安全间取舍,重写(Rewrite)压缩体积。Redis 4.0+ 混合持久化 = RDB 快照 + 增量 AOF,兼顾两者。
- ⏰ 过期删除与内存淘汰:删除策略是惰性删除 + 定期删除(主动被动结合);内存淘汰 8 种策略里重点背 noeviction / allkeys-lru / volatile-lru / allkeys-random。注意 Redis 的 LRU 是采样近似实现,不是严格 LRU。
- 🔒 分布式锁(SETNX + Lua):分布式锁要满足互斥、防死锁(过期时间)、防误删(value 带唯一标识,Lua 脚本原子校验再删)、可重入 / 续期(看门狗)。Redlock 是官方多节点方案但学界有争议,能讲出利弊即可。
- 🏥 高可用与治理:主从复制保证数据冗余(全量 + 增量同步);Sentinel 哨兵负责监控、选主、通知,实现故障自动切换;Cluster 用 16384 个槽位分片,节点增减走 MOVED / ASK 重定向。还要会答大 Key / 热点 Key 的危害与 SCAN 渐进处理,以及 Redis vs Memcached 的选型对比(多数据结构、持久化、集群是 Redis 的三张王牌)。
面向算法 / 后端秋招的 Redis 高频考点整理。每个主题包含:定义与原理讲解、 公式或伪代码、可直接运行的 Python 3 示例、对比表格、面试追问与标准回答、 易错点 / 面试点评。涉及 redis-py 的示例需本机装有 Redis 服务,纯算法示例(布隆过滤器、 LRU 等)可零依赖直接运行。
本文目录 1. Redis 基础:单线程为什么快 + 五种基本数据结构 2. 缓存穿透 / 击穿 / 雪崩(含布隆过滤器 Python 实现) 3. 缓存与数据库一致性(延时双删 / CDC / Cache-Aside) 4. 持久化:RDB vs AOF vs 混合持久化 5. 过期策略与淘汰策略(8 种 + LRU 近似实现) 6. 分布式锁(SETNX + Lua + Redlock + 看门狗) 7. 高可用:主从复制 / Sentinel / Cluster 8. 大 Key 与热点 Key 问题 9. Redis vs Memcached 对比
1. Redis 基础:单线程为什么快 + 五种基本数据结构¶
1.1 定义¶
Redis(Remote Dictionary Server) 是一个基于内存的 Key-Value 数据库,支持丰富的数据结构、持久化、主从复制、哨兵与集群,广泛应用于缓存、分布式锁、排行榜、消息队列等场景。
1.2 单线程为什么快(经典四问)¶
| 原因 | 说明 |
|---|---|
| 纯内存操作 | 读写内存(纳秒级),没有磁盘 IO 随机访问的瓶颈 |
| IO 多路复用 | 用 epoll 单线程同时监听海量 socket,事件就绪才回调处理,无阻塞等待 |
| 无锁、无上下文切换 | 单线程执行命令,天然避免加锁/解锁、线程切换、CPU 缓存失效的开销 |
| 高效数据结构 | 底层用 SDS、跳表、压缩列表等精心设计的数据结构,命令复杂度多为 O(1)/O(log N) |
注意:Redis 的「单线程」指执行命令的线程只有一个(6.0 前整个网络模型单线程;6.0 后引入多线程 IO 读写,但命令执行仍单线程),持久化、过期淘汰等由后台线程完成。
1.3 五种基本数据结构对照表¶
| 结构 | 命令示例 | 典型应用 | 底层实现 |
|---|---|---|---|
| String | SET / GET / INCR / SETNX / MSET |
缓存、计数器、分布式锁、限流 | SDS(简单动态字符串)、int/embstr/raw 编码 |
| List | LPUSH / RPOP / LRANGE / BLPOP |
消息队列、最新列表、任务队列 | quicklist(ziplist 节点链表) |
| Hash | HSET / HGET / HINCRBY / HGETALL |
对象缓存(用户信息、购物车) | listpack/ziplist 或 dict(哈希表) |
| Set | SADD / SISMEMBER / SPOP / SUNION |
去重、共同关注、随机抽奖 | intset 或 dict(值为 NULL 的哈希表) |
| ZSet | ZADD / ZRANGE / ZSCORE / ZINCRBY |
排行榜、延时队列、滑动窗口限流 | skiplist + dict 或 listpack |
1.4 底层实现要点¶
💡 小白加餐:先把这几个名词翻译成人话,再往下读(已会请跳过)
- SDS:C 字符串的改进版——记录长度、自动扩容、二进制安全(可存 \0),避免
strlenO(n) 与缓冲区溢出。 - quicklist:双向链表,每个节点是一个 ziplist/listpack(压缩列表),兼顾内存紧凑与首尾操作高效。
- skiplist + dict:跳表维护有序,dict 维护 member→score 映射,保证
ZSCORE也是 O(1)。 - 编码转换(以小哈希为例):元素少且值小时用 listpack(ziplist),超过阈值(如 512 个或 64 字节)自动转为 哈希表。
1.5 Python 3 可运行示例(redis-py 基本操作)¶
"""redis-py 基本操作示例。需先启动 redis-server(默认 6379 端口)。
pip install redis 后可直接运行。"""
try:
import redis
except ImportError:
print("请先安装: pip install redis")
raise SystemExit
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
# String:计数器(INCR 原子自增)
r.set('counter', 0)
print('INCR ->', r.incr('counter'), r.incr('counter'))
# List:消息队列(LPUSH + BRPOP)
r.rpush('mq', 'job1', 'job2')
print('LPOP ->', r.lpop('mq'))
# Hash:对象缓存
r.hset('user:1001', mapping={'name': 'alice', 'age': 18})
print('HGET ->', r.hget('user:1001', 'name'))
# Set:去重 / 共同关注
r.sadd('follow:a', 'u1', 'u2'); r.sadd('follow:b', 'u2', 'u3')
print('共同关注 ->', r.sinter('follow:a', 'follow:b'))
# ZSet:排行榜(分数从高到低)
r.zadd('rank', {'alice': 90, 'bob': 80, 'carol': 95})
print('Top2 ->', r.zrevrange('rank', 0, 1, withscores=True))
1.6 面试追问¶
追问 1:Redis 6.0 引入多线程 IO,还是单线程吗? 标准回答: 是的——命令执行依然是单线程(保证原子性与无锁);多线程只用于socket 读写的编解码,把耗时 IO 从主线程剥离,网络吞吐提升,但命令语义不变。
追问 2:单线程执行命令会不会太慢?
标准回答: 单命令都是微秒级,瓶颈通常在网络 IO 和内存;真正要防的是 O(N) 危险命令(KEYS *、大 Key 的 HGETALL、SMEMBERS),它们会阻塞主线程(「慢查询」)。
追问 3:String 和 Hash 存对象怎么选?
标准回答: 整体读写用 String(JSON 序列化)简单高效;需要频繁改单个字段(如用户积分、购物车数量)用 Hash(HINCRBY 原子且只传一个字段,省带宽省内存)。
⚠️ 易错点:ZSet 底层是跳表 + dict 两套结构;「跳表为什么不用红黑树」是高频追问——跳表实现简单、支持范围查询、区间插入删除 O(logN),且与 dict 共享 member 无冗余内存问题。
2. 缓存穿透 / 击穿 / 雪崩¶
2.1 定义¶
💡 三个问题的生活版: - 穿透:坏家伙老拿「查无此人」的假 ID 来查,前台(缓存)每次都跑到里屋(DB)翻一遍——根本没这人,翻也白翻。 - 击穿:最火的柜台(热点 key)恰好歇 1 分钟,所有顾客同时涌向里屋。 - 雪崩:整栋楼的柜台约好同一分钟一起歇(大量 key 同时过期),里屋瞬间被挤爆。
| 问题 | 定义 | 特征 |
|---|---|---|
| 缓存穿透 | 查询根本不存在的 key,缓存和数据库都没有,每次请求都打到 DB | 恶意攻击 / 非法参数,DB 压力大且缓存永远防不住 |
| 缓存击穿 | 一个热点 key 恰好过期,瞬间大量请求同时穿透到 DB | 单个 key 过期瞬间,DB 被打爆 |
| 缓存雪崩 | 大量 key 同时过期(或 Redis 宕机),海量请求直击 DB | 整片缓存失效,DB 雪崩 |
区别一句话:穿透 = 查不到(缓存永远 Miss);击穿 = 热点 key 过期(单个);雪崩 = 大量 key 同时过期 / 服务不可用(批量)。
2.2 解决方案对比表¶
| 问题 | 方案 | 说明 |
|---|---|---|
| 穿透 | 布隆过滤器 | 请求前先判「可能存在」,过滤掉不存在 key |
| 穿透 | 缓存空值 + 短过期 | 不存在也缓存 null(TTL 短,如 5 分钟),并加业务兜底 |
| 穿透 | 参数校验 / 限流 | 非法参数直接拒绝(如 id < 0) |
| 击穿 | 互斥锁(Mutex) | 只有一个线程去查 DB 重建缓存,其余等待/降级 |
| 击穿 | 逻辑过期 | key 永不过期,逻辑时间过期后异步重建,请求先返回旧值 |
| 雪崩 | 随机过期时间 | 过期时间加随机抖动(如 ±随机数),错峰失效 |
| 雪崩 | 多级缓存 / 熔断降级 | 本地缓存兜底、限流、开关降级 |
2.3 布隆过滤器原理与公式¶
💡 类比:布隆过滤器 = 一张「盖了 k 个章」的名单。每个名字(key)经过 k 个哈希函数,等于在名单上盖 k 个不同颜色的章; 查人 = 看他该盖的那 k 个章是否都盖了。
为什么不漏报(假阴性 = 0)? 只要真的插进去过,那 k 个章一定都盖了——查的时候 k 个位必然全为 1。 所以「查到不在的一定真不在」:就像你确定盖过章,撕掉重查也一定盖着。
为什么可能误报(假阳性)? 不同名字可能盖到同一个章位(哈希冲突)。查一个没插过的名字时, 它该盖的 k 个位置可能恰好被别的名字盖满了——k 个坑位都被别人占了,也会误报「在」。 类比:A 没登记,但他该用的那张桌子恰好被 B、C、D 占满,就误以为 A 也在。
所以结论只有两个方向:返回「不在」→ 100% 不在(不漏报);返回「在」→ 只是「很可能在」(会误报)。
两个词先定义:假阴性 = 明明在里面却说不在(布隆永远不发生);假阳性 = 明明不在却说在(可能发生)。
公式怎么记(参数直觉):位数组越长(m 越大)→ 位越稀疏 → 冲突越少 → 误判率 p 越低; 元素越多(n 越大)→ 位被占得越满 → 误判率越高。所以 m、n 的关系是「空间换精度」: 想要 1% 误判率,大约每个元素要分到 9.6 个位(m ≈ 9.6n)——太小位数组会挤爆、太大浪费内存。
- 原理:一个 m 位的位数组 + k 个哈希函数。插入时把元素经 k 个哈希映射到 k 个位并置 1;查询时若 k 个位全为 1 则「可能存在」,否则必然不存在。
- 特点:不会漏报(假阴性为 0),但可能误报(假阳性);不可删除(可用计数布隆过滤器)。
- 公式(给定期望元素数 n 与误判率 p):
位数组长度 m = - n·ln(p) / (ln2)^2
哈希函数个数 k = (m/n) · ln2
实际误判率 p' = (1 - e^(-k·n/m))^k
2.4 Python 3 可运行示例(布隆过滤器实现)¶
"""纯 Python 布隆过滤器(标准库,可直接运行)。"""
import hashlib, math
class BloomFilter:
def __init__(self, n: int, p: float = 0.01):
self.m = int(-n * math.log(p) / (math.log(2) ** 2)) # 位数组长度
self.k = max(1, int(self.m / n * math.log(2))) # 哈希函数个数
self.bits = [0] * self.m
def _hashes(self, item: str):
# 用 md5/sha1 双摘要派生 k 个相互独立的哈希值
h1 = int(hashlib.md5(item.encode()).hexdigest(), 16)
h2 = int(hashlib.sha1(item.encode()).hexdigest(), 16)
return [(h1 + i * h2 + i * i) % self.m for i in range(self.k)]
def add(self, item: str):
for idx in self._hashes(item):
self.bits[idx] = 1
def contains(self, item: str) -> bool:
return all(self.bits[idx] for idx in self._hashes(item))
if __name__ == '__main__':
bf = BloomFilter(n=1000, p=0.01)
for i in range(1000):
bf.add(f"user:{i}")
print("已插入 1000 个 key")
print("user:500 存在? ->", bf.contains("user:500")) # True(必然)
print("user:9999 存在? ->", bf.contains("user:9999")) # False(大概率)
# 统计误判率
false_positive = sum(bf.contains(f"miss:{i}") for i in range(1000))
print(f"1000 个不存在 key 的误判数 ≈ {false_positive}(理论 ~1%)")
2.5 互斥锁(击穿)与逻辑过期(伪代码)¶
# —— 方案 A:互斥锁(SETNX 抢锁,只有一个线程回源重建)——
# key = 热点缓存key; lock_key = key + ':lock'
"""
value = GET(key)
if value is None: # 缓存未命中(过期)
if SETNX(lock_key, 1, NX=True, EX=10): # 抢到锁
try:
value = query_db(key) # 只有一个线程查 DB
SETEX(key, 300, value) # 重建缓存
finally:
DEL(lock_key)
else:
sleep(20ms); return GET(key) # 没抢到:短暂等待后重试/降级
"""
# —— 方案 B:逻辑过期(key 永不过期,异步重建)——
"""
SET(key, value) # 永不过期;value 中内嵌逻辑过期时间
read 时:
判断 value.logic_expire < now ?
是:返回旧 value,同时后台线程抢锁重建(防止击穿)
否:直接返回 value
"""
2.6 面试追问¶
追问 1:布隆过滤器能删除元素吗?
标准回答: 标准布隆过滤器不能删除(删除一个位可能影响其他元素);可用计数布隆过滤器(Counting Bloom Filter),但计数溢出会退化。Redis 官方 RedisBloom 模块的 BF.INSERT / BF.EXISTS 可直接使用。
追问 2:互斥锁方案中,没抢到锁的请求怎么办? 标准回答: 短暂自旋重试读缓存,或返回旧数据/降级数据(逻辑过期方案天然支持返回旧值),避免大量请求空转打爆 DB。
追问 3:穿透和击穿如何同时防? 标准回答: 入口布隆过滤器防穿透(过滤不存在 key)+ 热点 key 互斥锁/逻辑过期防击穿 + 过期时间随机化防雪崩,三层组合。
⚠️ 易错点:缓存空值只能防「反复查询同一个不存在 key」的穿透;攻击者每次用不同随机 key 时,空值缓存会占满内存,必须配合布隆过滤器。
3. 缓存与数据库一致性¶
3.1 问题定义¶
缓存与数据库是两套存储,更新时序不同会产生不一致:缓存是旧值、DB 是新值,或反之。核心矛盾:先更新谁、谁先失效/生效。
3.2 Cache-Aside(旁路缓存)模式¶
- 读:先查缓存,命中直接返回;未命中查 DB,回填缓存。
- 写:先更新 DB,再删除缓存(del);下一次读未命中再回填。
为什么写用「删缓存」而不是「更新缓存」?更新缓存需要知道新值且易与并发写冲突;删除是惰性的——下次读时回填,实现简单且最终一致。
3.3 时序问题与对策¶
| 方案 | 做法 | 评价 |
|---|---|---|
| 先删缓存,再更新 DB | 删除 → 写库 | 删除后、写库前有读会回填旧值 → 不一致,已基本弃用 |
| 先更新 DB,再删缓存 | 写库 → 删除 | 主流方案;仍有「读旧值回填」窗口,用延时双删缓解 |
| 延时双删(Delayed Double Delete) | 写库 → 删缓存 → 延时 500ms~1s 再删一次 | 消除回填旧值的窗口;代价是短暂不一致可接受 |
| binlog / CDC 订阅 | 订阅 DB binlog(Canal),异步删缓存/更新缓存 | 解耦、可靠,删缓存失败可重试;最终一致性强 |
| 消息队列 + 重试 | 删除失败写入 MQ 重试 | 保证「删除」不丢 |
延时双删(Python 伪代码 + redis-py):
"""延时双删:先更新 DB,再删缓存;短暂延时后二次删除。"""
import redis, time
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
def update_user(user_id, new_data):
# 1. 更新数据库(示意)
update_db(user_id, new_data) # UPDATE user SET ... WHERE id=?
# 2. 第一次删缓存
r.delete(f"user:{user_id}")
# 3. 延时(等可能的「读旧值→回填」完成)
time.sleep(0.5)
# 4. 第二次删缓存(兜底)
r.delete(f"user:{user_id}")
def update_db(user_id, data):
print(f"[DB] UPDATE user {user_id} -> {data}")
3.4 CAP 权衡说明¶
- CAP:分布式系统在一致性(C)/ 可用性(A)/ 分区容错性(P) 中最多满足两项;网络分区不可避免 → 必须选 P,再在 C 与 A 之间权衡。
- 缓存与 DB 是两副本,天然存在最终一致性(Eventually Consistent)而非强一致:
- 追求强一致:读 DB 前先失效缓存 + 串行化,成本高、性能差,缓存场景通常不选;
- 缓存场景的默认选择:AP(可用性优先)+ 最终一致——短暂读到旧值可接受(如 500ms 内);
- 需要近似强一致时用 Cache-Aside + 延时双删 / binlog 订阅 + 失败重试,把不一致窗口压到最小。
3.5 面试追问¶
追问 1:为什么「先删缓存再更新库」不好? 标准回答: 删缓存后、写库前的空窗期内,若有读请求命中 DB 旧值并回填缓存,缓存又变成旧值且可能长期不更新(直到下次过期),不一致窗口大且难以收敛。
追问 2:延时双删的「延时」怎么选? 标准回答: 取「读请求从 DB 读旧值到回填缓存」的最坏耗时(一般数百毫秒到 1s),太大则短暂不一致过久;工程上通常 500ms 并配合第二次删除失败重试。
追问 3:为什么不用「先更新缓存」? 标准回答: 并发写时「更新缓存」的顺序与写库顺序可能不一致(写库乱序导致缓存覆盖成旧值),且每次写都写缓存浪费 IO;删除缓存 + 惰性回填天然规避这两个问题。
⚠️ 易错点:删除缓存可能失败(网络抖动),这是不一致的主要来源——务必用 binlog 订阅 / MQ 重试兜底;「延时双删」不是强一致方案,它只是把不一致窗口缩小到工程可接受。
4. 持久化:RDB vs AOF¶
4.1 定义¶
- RDB(快照):把某一时刻的全量数据以二进制格式写入
.rdb文件,恢复快、体积小。 - AOF(追加日志):把每一条写命令追加到
.aof文件,恢复慢但丢失数据更少(可配 fsync)。
4.2 RDB 触发方式¶
💡 先搞懂 fsync 再读这张表:程序写文件时,数据先进操作系统的一块内存缓存,操作系统「有空了」才真正写入磁盘。 fsync 就是一条命令:请求操作系统立刻把这块缓存真正写到磁盘——写盘完成才放心;没 fsync 时数据还在内存缓存里,一断电就没了。
💡 类比:记账本先记在草稿上,每 1 秒誊写到正式账本。Redis 收到写命令先记在内存(草稿);
everysec= 每隔 1 秒把草稿誊写到正式账本(磁盘)一次。断电时:刚记在草稿上、还没到 1 秒誊写 → 这笔丢了; 誊写完成后 → 不丢。所以「最多丢 1 秒数据」= 最多丢掉最近 1 秒内还没誊写的那几笔。always= 每记一笔立刻誊写(最安全但最慢);no= 交给操作系统自己决定何时写(最快,但断电可能丢比较多)。
- 手动:
SAVE(阻塞主线程,生产禁用)/BGSAVE(fork 子进程写快照,不阻塞); - 自动:配置文件
save <seconds> <changes>,如save 900 1(900 秒内 ≥1 次修改)、save 300 10、save 60 10000; - 关闭时:正常
SHUTDOWN会生成 RDB;FLUSHALL等不影响已有文件。
4.3 AOF 三种 fsync 策略¶
| 策略 | 行为 | 数据安全 | 性能 |
|---|---|---|---|
always |
每条写命令都 fsync | 最多丢 1 条命令 | 最慢 |
everysec(默认) |
每秒 fsync 一次 | 最多丢 1 秒数据 | 折中 |
no |
交给操作系统刷盘 | 可能丢较多数据 | 最快 |
4.4 AOF 重写(Rewrite)¶
- 问题:AOF 无限增长,恢复慢、占磁盘。
- 方案:AOF 重写——根据当前内存数据集生成最小命令集写入新 AOF(如
INCR100 次合并成SET 100),由子进程执行,父进程把重写期间的增量命令缓冲并追加到新文件,保证不丢数据。 - 触发:手动
BGREWRITEAOF;自动按auto-aof-rewrite-percentage/auto-aof-rewrite-min-size。
4.5 RDB vs AOF 对比表¶
| 维度 | RDB | AOF |
|---|---|---|
| 数据格式 | 二进制快照 | 追加写命令(文本/二进制协议) |
| 数据丢失 | 上次快照后的修改全丢(取决于 save 策略) | everysec 最多丢 1s;always 不丢 |
| 恢复速度 | 快(直接加载) | 慢(重放所有命令) |
| 文件大小 | 小(压缩快照) | 大(可重写控制) |
| 对性能影响 | BGSAVE fork 有短暂内存/CPU 开销 | 写放大,always 策略影响大 |
| 适用场景 | 冷备、快速恢复、灾备 | 数据安全要求高的缓存 |
4.6 混合持久化(Redis 4.0+)¶
💡 COW(Copy-On-Write,写时复制)是什么? 复制数据时,一开始只复制目录(页表 / 指针),大家共享同一份数据; 只有某人真要改动某一页时,才把那页真正复制一份给他改——被复制的那一页就叫「写时复制」。
💡 类比:复印整本书 vs 只记改动。BGSAVE 要生成一份快照:如果「复制整本书」→ 内存瞬间翻倍、又慢又贵; COW 的做法是先共看同一本书,谁要改哪页,就只复印那页给谁改。fork 出的子进程看的是「这一刻的书」(快照), 主进程之后每改动一页,那一页才被真正复制——改动越少,额外内存开销越小。 为什么 fork 本身会短暂阻塞?fork 要复制「页表」(相当于把书的目录抄一遍,记录每页在哪)——内存越大目录越长,抄目录越久。 顺带定义 页表:操作系统用来记录「每个内存页在哪、谁在用」的目录。
- 方案:AOF 重写时生成 RDB 格式的「基础快照」 + 快照之后的新命令追加到 AOF 尾部;
- 收益:加载时先秒级加载 RDB,再重放少量增量命令——兼顾恢复速度与数据安全;
- 配置:
aof-use-rdb-preamble yes。
4.7 面试追问¶
追问 1:BGSAVE 会阻塞主线程吗? 标准回答: 磁盘写入由子进程完成不阻塞;但 fork 本身可能短暂阻塞(COW 复制页表,内存越大耗时越长),且 COW 写时复制会带来额外内存开销——大内存实例要关注。
追问 2:RDB 和 AOF 能同时开吗? 标准回答: 可以(生产常用组合)。加载优先级 AOF 高于 RDB(AOF 数据更全);开启混合持久化后加载更快。
追问 3:为什么 Redis 重启后优先用 AOF 恢复? 标准回答: 因为 AOF 记录的命令比 RDB 快照更接近最新状态,数据丢失更少;加载完成后再由 RDB/混合文件提供性能。
⚠️ 易错点:
SAVE(同步阻塞)与BGSAVE(异步)别混淆;fork 子进程是「写时复制」——子进程快照期间主进程的修改不会进 RDB,而是依赖 AOF/下次快照。
5. 过期策略与淘汰策略¶
5.1 过期删除策略(删「已过期」的 key)¶
| 策略 | 原理 | 缺点 |
|---|---|---|
| 惰性删除 | 访问 key 时才检查是否过期,过期则删 | 过期 key 可能长期占用内存(不被访问就一直在) |
| 定期删除 | 后台定时随机抽一批带过期时间的 key 检查删除 | 抽样不全面,仍有残留 |
| 组合(Redis 实际采用) | 惰性删除 + 定期删除:被访问时惰性删;后台周期抽样删 | 两者都漏掉的过期 key 靠内存淘汰兜底 |
5.2 内存淘汰策略(内存不够时「驱逐」key,8 种)¶
💡 TTL(Time To Live,生存时间)是什么:给 key 设的「保质期」,过期自动失效(
volatile-ttl就是「谁的保质期先到先扔谁」)。💡 24 位 LRU 时钟是什么:每个 key 记一个「最近一次被访问的时刻」,占 24 位(一个循环刻度)。 内存满时随机抽 5 个 key,把其中「最近访问时刻」最早的淘汰——近似 LRU 不追着全局最旧的找, 而是在小样本里挑最旧的,成本低、效果接近精确 LRU(精确 LRU 要维护双向链表 + 哈希表,代价高)。
| 策略 | 作用域 | 行为 |
|---|---|---|
noeviction(默认) |
— | 不淘汰,写命令直接报错 |
allkeys-lru |
所有 key | 淘汰最近最少使用 |
volatile-lru |
仅设置了过期时间的 key | 淘汰最近最少使用 |
allkeys-lfu |
所有 key | 淘汰最不经常使用(频次) |
volatile-lfu |
仅有过期时间的 key | 淘汰最不经常使用 |
allkeys-random |
所有 key | 随机淘汰 |
volatile-random |
仅有过期时间的 key | 随机淘汰 |
volatile-ttl |
仅有过期时间的 key | 淘汰剩余 TTL 最小的 key |
口诀:LRU/LFU/Random/TTL × (allkeys/volatile) + noeviction = 8 种;volatile 系策略若没有过期 key 则退化为 noeviction。
5.3 LRU 近似实现原理¶
- 真实 LRU 需要双向链表 + 哈希表,代价高;
- Redis 的 近似 LRU:每个 key 记录 24 位 LRU 时钟(lru 字段),淘汰时随机采样 N 个(默认 5),驱逐其中 lru 时间最早的 key,并维护一个候选池(pool)提升淘汰质量;
- 改进:LFU(Redis 4.0+)用对数衰减的访问频次计数器,抵抗「偶尔访问的热点被 LRU 误淘汰」。
5.4 Python 3 可运行示例(LRU 缓存实现 + 近似 LRU 采样)¶
"""标准库实现 LRU 缓存 + 近似 LRU 采样(可直接运行)。"""
from collections import OrderedDict
import random
class LRUCache:
"""O(1) 的精确 LRU:OrderedDict 移动元素到末尾实现。"""
def __init__(self, capacity: int):
self.cap = capacity
self.d = OrderedDict()
def get(self, key):
if key not in self.d:
return -1
self.d.move_to_end(key) # 最近使用 -> 末尾
return self.d[key]
def put(self, key, value):
if key in self.d:
self.d.move_to_end(key)
self.d[key] = value
if len(self.d) > self.cap:
self.d.popitem(last=False) # 淘汰最久未使用(头部)
def redis_approx_lru(sample_size=5):
"""模拟 Redis 近似 LRU:随机采样 + 淘汰最早访问的 key。"""
pool = {f"k{i}": random.randint(0, 100) for i in range(50)} # lru 时钟越小越旧
sample = random.sample(list(pool.items()), sample_size)
victim = min(sample, key=lambda kv: kv[1])
print(f"采样 {sample_size} 个: {sorted(sample, key=lambda kv: kv[1])[:3]} ...")
print(f"淘汰最久未使用: {victim[0]} (lru={victim[1]})")
return victim[0]
if __name__ == '__main__':
c = LRUCache(2)
c.put('a', 1); c.put('b', 2); c.get('a'); c.put('c', 3)
print("精确 LRU 淘汰 ->", c.d) # {'b':2, 'c':3},a 保留
print("近似 LRU 采样淘汰 ->", redis_approx_lru())
5.5 面试追问¶
追问 1:为什么 Redis 不用精确 LRU? 标准回答: 精确 LRU 需要维护双向链表 + 哈希表且每次访问都要移动节点(指针操作多、内存占用大);近似 LRU + 采样在内存与淘汰质量之间取得平衡,实测与精确 LRU 差距很小。
追问 2:volatile-lru 和 allkeys-lru 怎么选? 标准回答: 业务 key 都设过期时间用 volatile-lru(保留长期驻留的关键数据);缓存场景(都可淘汰)用 allkeys-lru;注意 volatile 系在「无过期 key」时退化为 noeviction,可能触发写报错。
追问 3:LFU 相比 LRU 好在哪里? 标准回答: LFU 统计访问频次,不会被「一次偶然访问」误提升热度;适合低频热点常驻场景(如接口限流计数)。代价是维护频次计数器,实现更复杂。
⚠️ 易错点:过期删除 ≠ 内存淘汰——前者删「已过期」的 key(惰性+定期),后者在内存满时驱逐「未过期」的 key(8 种策略);两个机制同时存在,面试常混淆。
6. 分布式锁¶
6.1 需求与 SETNX 原子性问题¶
- 场景:多实例/多进程互斥访问共享资源,单机锁(
threading.Lock)无法跨进程。 - 朴素方案:
SETNX lock_key value抢锁 +EXPIRE lock_key 30设过期。
问题 1(非原子):
SETNX 成功 → 进程崩溃 → 没设 EXPIRE → 锁永不释放(死锁)
问题 2(误删):
A 持锁超时释放后 B 拿到锁;A 的延迟 DEL 把 B 的锁删掉
6.2 官方推荐方案(原子 Lua 脚本)¶
- 加锁:
SET lock value NX EX 30(Redis 2.6.12+ 一条命令原子完成「NX + EX」); - 释放锁:用 Lua 脚本「先校验 value(唯一标识,防误删),再 DEL」,保证检查与删除的原子性:
-- 释放分布式锁(官方推荐写法)
-- KEYS[1] = 锁的 key, ARGV[1] = 持有者唯一标识(如 UUID)
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
else
return 0
end
6.3 Python 3 可运行示例(redis-py + Lua 释放锁)¶
"""分布式锁完整示例(需 redis-server,可直接运行)。
加锁: SET key value NX EX;释放: Lua 校验唯一标识后 DEL。"""
import redis, uuid, time
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
UNLOCK_LUA = """
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
else
return 0
end
"""
def acquire(lock_key, token, ttl=10):
return r.set(lock_key, token, nx=True, ex=ttl) # NX + EX 原子
def release(lock_key, token):
return r.eval(UNLOCK_LUA, 1, lock_key, token) == 1
if __name__ == '__main__':
lock_key, token = 'order:123:lock', str(uuid.uuid4())
if acquire(lock_key, token):
try:
print("抢锁成功,执行临界区业务...")
time.sleep(0.5)
finally:
ok = release(lock_key, token) # 校验 token 后删除
print("释放锁成功" if ok else "锁已被他人持有/过期")
else:
print("抢锁失败,其他线程持有锁")
6.4 看门狗(Watchdog)续期¶
💡 GC 停顿是什么? 很多语言(Java/Go)有自动回收内存的机制(GC),回收时程序会被「暂停一小段时间」 (像打扫房间时全家都得先停下手里的活)。GC 停顿就是这段「被暂停、无法执行代码」的时间。 分布式锁靠「过期时间」兜底:若持锁进程恰好被 GC 停了几十秒,锁在自己不知情时过期,别人就能抢到—— 这正是 Redlock 争议里「GC 停顿导致锁提前失效」的含义。
- 问题:业务执行时间超过锁 TTL → 锁提前过期,其他线程抢锁 → 并发执行。
- 方案:看门狗——持有锁期间后台线程周期性(如每 TTL/3)对锁 续期,业务结束释放时取消续期;类比 Redisson 的
watchdog(默认锁 30s,每 10s 续期)。 - 注意:看门狗续期也是「续命」,进程宕机后锁仍会过期(避免死锁)——这是分布式锁「自动失效」特性的价值。
6.5 Redlock 思想与争议¶
💡 为什么 Lua 脚本「原子执行」? Redis 单线程执行命令:一条执行完才执行下一条。 Lua 脚本被当成一整段命令提交,执行期间不会插入其他客户端的任何命令——相当于一个服务员一口气把 「先看名字 → 再删锁」做完,中间没人能插队。分开两条命令执行,中间就可能被别人插队(变成误删)。
💡 可重入(Reentrant)锁是什么? 同一个执行者已经持有锁的情况下,还能再次成功获取同一把锁 (锁记一个「重入次数」,每次重入 +1、释放 -1,减到 0 才真正释放)。类比:你进了洗手间又出来拿东西, 认识你的人允许你再进一次。分布式场景用「线程标识 + 计数器」实现(Redisson 支持)。
- 思想(Redis 作者提出):在 N 个独立 Redis 节点(通常 5)上都尝试加锁,大多数(N/2+1)成功且总耗时 < TTL 才算加锁成功;释放时对所有节点释放。
- 目的:避免单点 master 故障丢锁后锁失效。
- 争议(Martin Kleppmann 批评):
- 依赖时钟:节点 GC 停顿/时钟跳变会导致锁提前失效或被误判;
- 加锁过程本身不是原子的跨节点事务,存在「加了一半锁进程暂停」的窗口;
- 业界共识:单 Redis + Lua + 看门狗对绝大多数场景足够;追求强一致应改用 ZooKeeper(临时节点 + 顺序节点)/ etcd(租约)。
6.6 面试追问¶
追问 1:为什么释放锁要用 Lua? 标准回答: 「get 校验 + del 删除」两步若分开执行,可能在校验后、删除前锁被其他线程替换,导致误删他人锁;Lua 脚本在 Redis 中原子执行,杜绝竞态。
追问 2:锁过期但业务没执行完怎么办? 标准回答: 用看门狗续期(Redisson 默认每 10s 续 30s 锁),业务结束主动释放;进程崩溃则锁自然过期,不会死锁——「续期」与「自动过期」互补。
追问 3:Redlock 可靠吗?生产怎么选? 标准回答: Redlock 在时钟漂移、GC 停顿场景有理论缺陷,且实现重;绝大多数缓存场景单实例 + Lua + 看门狗足够;金融/强一致场景选 ZooKeeper / etcd 的临时顺序节点实现。
⚠️ 易错点:value 必须是唯一标识(UUID/线程号),删除前必须校验——否则会误删他人的锁;「SETNX + EXPIRE 两条命令」是经典非原子反例,面试必考。
7. 高可用:主从复制 / Sentinel / Cluster¶
💡 场景化:一次「全量 + 增量」复制(新员工入职版)。新从节点加入,相当于新员工入职: ① 主节点把「当前全部数据」拍一张快照(RDB)发给他(全量复制,拷贝整本账)——但拍照期间公司还在营业,新账目不能漏; ② 拍照开始后产生的新命令被写进一个暂存箱(repl_backlog,复制积压缓冲区),相当于「拍照期间的补记流水」; ③ 新员工加载完快照后,主节点把暂存箱里的补记流水再发给他(增量补发)——账就齐了。 之后若断线:断点还在暂存箱里 → 只补发断点后的命令(增量复制);断太久、断点被冲掉 → 重新全量复制。
💡 脑裂是什么? 一个团队因网络问题被分成两拨,两边都以为自己是合法的、同时干活—— 像公司断了网,两个部门各自以为自己是总部、各自发号施令,网络恢复后指令冲突、数据不一致。 哨兵 / 集群用「多数派确认 + 限制少数派继续写」防脑裂。
7.1 主从复制(Replication)¶
💡 类比:哨兵 = 保安巡逻队。主节点值班时,几个保安(哨兵进程)轮流确认「主节点还醒着吗」(心跳)。 一个保安说联系不上 = 主观下线(怀疑而已);多数保安都说联系不上 = 客观下线(quorum 确认),才敢换主——避免单个保安看走眼就乱换岗。 换谁当新主,由哨兵们用 Raft 先选出一个「保安队长」来执行。
- 全量复制:从节点首次连接 → 主节点
BGSAVE生成 RDB → 传输 RDB → 从节点加载;期间增量命令写入 repl backlog(复制积压缓冲区) 后补发。 - 增量复制:断线重连后,若断点仍在 repl_backlog 中 → 只补发断点后的命令(
PSYNC续传),否则退化为全量复制。 - 角色:一主多从,从节点只读(默认),写命令只在主节点执行。
7.2 哨兵(Sentinel)¶
💡 Gossip(八卦协议)是什么? 节点之间随机挑几个邻居、把「我知道的消息」讲给他们听,他们再随机讲给别人—— 像办公室里传八卦,不用群发,消息也能很快传遍所有人。Redis Cluster 用 Gossip 互相广播「谁活着、槽位在哪」, 槽位消息是位图(约 2KB),所以槽越多、心跳包越大(这就是追问 3 里 16384 而不是 65536 的原因之一)。
- 作用:监控(心跳检测主从)、自动故障转移(主节点客观下线 → 选举新主并让从节点切换)、通知(向客户端提供当前主节点地址)。
- 判定:主观下线(单哨兵认为失联)→ 客观下线(quorum 个哨兵都认为失联)→ 选举新主(Raft 选 Leader 哨兵执行切换)。
- 部署:哨兵至少 3 个(奇数,避免脑裂),哨兵之间用 Raft 选主。
7.3 Cluster 集群与槽位¶
- 概念:16384 个哈希槽(slot),分布在 N 个节点上(如 3 主 3 从,每主约 5461 槽)。
- 键分配公式:
slot = CRC16(key) % 16384;带{}的 hash tag 可把多个 key 归入同一槽(如{user:1}:info、{user:1}:cart)。 - 重定向:
- MOVED:key 的槽在其他节点 → 客户端收到
MOVED slot ip:port后更新路由缓存并跳转; - ASK:槽在迁移中 → 临时重定向,客户端不更新缓存(迁移完成前仍需回原节点确认)。
- 容灾:每个主节点配从节点,主挂从顶上(选举提升)。
7.4 Python 3 可运行示例(槽位计算与 MOVED/ASK 处理逻辑)¶
"""CRC16 槽位计算 + MOVED/ASK 重定向处理逻辑(标准库,可直接运行)。"""
def crc16(data: bytes) -> int:
poly = 0x1021
crc = 0
for b in data:
crc ^= b << 8
for _ in range(8):
crc = ((crc << 1) ^ poly) & 0xFFFF if crc & 0x8000 else (crc << 1) & 0xFFFF
return crc
def slot_of(key: str) -> int:
# 支持 hash tag: {user:1} 部分参与 CRC16
if '{' in key and '}' in key:
tag = key[key.index('{') + 1: key.index('}')]
return crc16(tag.encode()) % 16384
return crc16(key.encode()) % 16384
def handle_reply(reply, client):
"""简化模拟: 处理 MOVED / ASK / OK。"""
if reply.startswith('MOVED'):
_, slot, addr = reply.split()
print(f"槽 {slot} 已迁移到 {addr},更新本地路由缓存并重试")
return True
if reply.startswith('ASK'):
_, slot, addr = reply.split()
print(f"槽 {slot} 正在迁移,向 {addr} 发 ASKING 后重试(不更新缓存)")
return True
print("命令执行成功:", reply)
return False
if __name__ == '__main__':
for key in ['user:1001', 'cart:2002', '{user:1}:info', '{user:1}:cart']:
print(f"key={key:<16} slot={slot_of(key)}")
handle_reply('MOVED 1234 10.0.0.2:6379', None)
handle_reply('ASK 1234 10.0.0.3:6379', None)
7.5 面试追问¶
追问 1:全量复制为什么用 RDB 而不是 AOF? 标准回答: RDB 是压缩二进制快照,传输体积小、从节点加载快;AOF 重放命令慢且文件大。同步期间的增量命令由 repl_backlog 缓冲补发。
追问 2:哨兵怎么防止脑裂?
标准回答: 客观下线需要 quorum(多数哨兵)确认;新主选举由哨兵 Leader 用 Raft 完成;同时主节点可通过 min-replicas-to-write 等配置限制「与多数失联的旧主」继续写,减少双写脑裂。
追问 3:为什么是 16384 个槽,不是 65536? 标准回答: 16384 槽的 CRC16 取模分布足够均匀;槽信息以位图(bitmap)在节点间传播(2KB 大小),槽再多会增大 Gossip 心跳包;且 Redis 集群节点规模通常在千级以内,16384 粒度已满足(官方设计取舍)。
追问 4:MOVED 和 ASK 的区别? 标准回答: MOVED:槽已经属于目标节点,客户端要更新路由缓存,后续直接访问新节点;ASK:槽正在迁移(仅本次),客户端发 ASKING 后去目标节点查一次,不更新缓存。
⚠️ 易错点:Cluster 不支持跨槽的多 key 操作(
MGET多个不同槽的 key 报错),除非用 hash tag;从节点默认不可写,读写分离要配readonly。
8. 大 Key 与热点 Key 问题¶
8.1 定义¶
- 大 Key(Big Key):单个 key 的 value 很大——如 String 超过 10KB~100KB、集合类 key 元素超过 万级(如 10 万个元素的 Hash/Set/ZSet)。
- 热点 Key(Hot Key):单位时间被超高频率访问的 key(如秒杀商品、明星热搜),单节点 CPU/网卡打满。
8.2 危害¶
| 问题 | 危害 |
|---|---|
| 大 Key | ① 读取/删除/迁移时阻塞主线程(O(N) 命令);② 内存倾斜(集群单节点压力大);③ 网络传输大(带宽占用);④ 持久化 fork/COW 开销大 |
| 热点 Key | ① 单节点 CPU/网卡打满,集群其他节点空闲(数据倾斜 + 访问倾斜);② 缓存击穿时放大 DB 压力;③ 慢查询拖累整体 |
8.3 处理方案¶
大 Key:
- 拆分:把大 Hash/Set 按业务维度拆成多个小 key(user:1001:info、user:1001:tags);
- 压缩:String 存压缩后的数据(如 gzip 的 JSON);
- 渐进式操作:删除用 UNLINK(异步释放内存,4.0+)或 SCAN + HDEL/SREM 分批删;
- 禁用危险命令:KEYS *、大 key 的 HGETALL/SMEMBERS 改 HSCAN/SSCAN 分批取。
热点 Key:
- 本地缓存(多级缓存):JVM/进程内缓存热点数据,先查本地再查 Redis,把热点流量挡在应用侧;
- 热点复制(key 打散):把热点 key 复制 N 份(hot:1…hot:N),请求随机访问副本,分散单节点压力;
- 读写分离 + 集群:把热点节点上的副本分散到多节点;
- 监控预警:redis-cli --hotkeys(LFU 统计)、info 命令监控,及时拆分。
8.4 Python 3 可运行示例(SCAN 渐进删除大 Key)¶
"""用 SCAN 分批删除大 Hash 的字段(标准库 + redis-py,可直接运行)。"""
import redis
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
def clear_big_hash(key, batch=1000):
"""分批 HDEL,避免一次性 HGETALL/DEL 阻塞主线程。"""
cursor, deleted = 0, 0
while True:
cursor, fields = r.hscan(key, cursor=cursor, count=batch)
if fields:
deleted += r.hdel(key, *fields.keys())
if cursor == 0:
break
print(f"共删除 {deleted} 个字段")
r.delete(key) # 空壳 key 直接删
print("大 Key 清理完成")
if __name__ == '__main__':
# 构造一个 10000 字段的测试 Hash
test_key = 'big:hash'
pipe = r.pipeline()
for i in range(10000):
pipe.hset(test_key, f'f{i}', f'v{i}')
pipe.execute()
clear_big_hash(test_key)
8.5 面试追问¶
追问 1:为什么大 Key 删除会阻塞?
标准回答: DEL 对集合类型需要逐个释放元素内存(O(N)),大 Key 会长时间占用主线程;4.0+ 用 UNLINK 异步释放,或 SCAN 分批删。
追问 2:热点 key 在集群里为什么是灾难? 标准回答: 集群按槽分布数据,热点 key 只落在一个槽/一个节点上——所有请求都打到同一节点,集群水平扩展失效,还伴随CPU/网卡打满与单点故障风险。
追问 3:热点 key 怎么提前发现?
标准回答: 业务埋点统计、redis-cli --hotkeys(需开 LFU)、监控 QPS 突增告警、代理层(Codis/Twemproxy)统计;发现后本地缓存 + key 打散双管齐下。
⚠️ 易错点:热点 key ≠ 大 key——前者是访问频率问题,后者是体积问题;面试要分别给出方案,别混为一谈。
9. Redis vs Memcached 对比¶
💡 CAS(Compare-And-Swap,比较并交换)是什么? 一句话:「先比一比,和预期一样才动手」的原子操作。 更新前先看当前值是否等于自己记的旧值:相等 → 更新成新值;不相等 → 说明已被改过,放弃并重试。 类比:去柜台改机票价格,先确认「现在还是 1000 吗」——是,才改成 1200;已经涨到 1100 就不改、重新查。 Memcached 用它实现乐观并发控制(对应 Redis 的 WATCH、数据库的乐观锁)。
9.1 对比表¶
| 维度 | Redis | Memcached |
|---|---|---|
| 数据结构 | String / List / Hash / Set / ZSet + 模块 | 仅 String(value 为字节数组) |
| 持久化 | RDB / AOF / 混合 | 无持久化(纯缓存) |
| 线程模型 | 单线程执行命令(IO 多路复用) | 多线程(每个核多线程处理) |
| 内存淘汰 | 8 种策略(LRU/LFU/Random/TTL) | 仅 LRU |
| 原子操作 | INCR/DECR/事务/Lua/发布订阅 | CAS(比较并交换)+ 简单命令 |
| 集群 | Cluster 槽位 + 哨兵 + 主从 | 客户端分片(一致性哈希),无内置集群 |
| 典型场景 | 缓存 + 分布式锁 + 排行榜 + 队列 | 纯 KV 缓存、超大并发读 |
| 内存效率 | 多种编码(int/embstr/ziplist) | 纯字节存储,简单场景内存略省 |
9.2 选型建议¶
- 需要数据结构丰富、持久化、分布式能力 → Redis(绝大多数场景);
- 只需要极简 KV 缓存、追求多线程吞吐 → Memcached(如纯对象缓存);
- 现代实践:几乎统一用 Redis(Memcached 已边缘化),但面试仍会考差异点。
9.3 面试追问¶
追问 1:为什么 Memcached 多线程却不如 Redis 全能? 标准回答: 多线程只提升网络读写吞吐,但牺牲了简单性与原子性(需要锁保护共享结构);Redis 单线程换来命令天然原子、无锁、实现简单,配合 IO 多路复用在大并发下依然够用,且功能远多于 Memcached。
追问 2:两者内存满了行为有什么不同? 标准回答: Memcached 只有 LRU 淘汰(且可关,关掉后写失败);Redis 默认 noeviction(写报错),可配 8 种策略——语义更可控。
追问 3:什么时候坚持用 Memcached? 标准回答: 纯字符串缓存、对多线程吞吐极致要求且完全不需要持久化/复杂结构的极简场景;现实中大多被 Redis 替代。
⚠️ 易错点:Memcached 没有内置集群与持久化——「Memcached 用一致性哈希做分布式」是客户端分片,不是服务端能力;Redis 的集群是服务端原生支持。
附:高频速记表(考前 5 分钟)¶
| 考点 | 一句话答案 |
|---|---|
| 单线程为何快 | 内存 + epoll 多路复用 + 无锁 + 高效数据结构 |
| ZSet 底层 | skiplist + dict(有序 + 按 member 查 score) |
| 穿透/击穿/雪崩 | 查不到 / 热点过期 / 批量过期,分别用布隆/互斥锁/随机 TTL |
| 布隆过滤器 | m 位数组 + k 哈希,不漏报、可误报,m = -n·ln(p)/(ln2)² |
| 一致性 | Cache-Aside + 延时双删 + binlog 订阅,最终一致 |
| RDB vs AOF | 快照快但丢数据多;AOF 慢但最多丢 1s(everysec) |
| 淘汰 8 策略 | LRU/LFU/Random/TTL × allkeys/volatile + noeviction |
| 分布式锁 | SET key val NX EX + Lua 校验删除 + 看门狗续期 |
| Cluster | slot = CRC16(key) % 16384;MOVED 更新缓存,ASK 不更新 |
| 大 Key vs 热点 | 体积大 vs 访问频;拆 key / UNLINK,本地缓存 + 副本打散 |
祝顺利上岸!本笔记配套仓库:
autumn-recruit-algo/05-八股与工程/。