Redis 八股与工程(秋招速通版)¶
面向算法 / 后端秋招的 Redis 高频考点整理。每个主题包含:定义与原理讲解、 公式或伪代码、可直接运行的 Python 3 示例、对比表格、面试追问与标准回答、 易错点 / 面试点评。涉及 redis-py 的示例需本机装有 Redis 服务,纯算法示例(布隆过滤器、 LRU 等)可零依赖直接运行。
本文目录
- Redis 基础:单线程为什么快 + 五种基本数据结构
- 缓存穿透 / 击穿 / 雪崩(含布隆过滤器 Python 实现)
- 缓存与数据库一致性(延时双删 / CDC / Cache-Aside)
- 持久化:RDB vs AOF vs 混合持久化
- 过期策略与淘汰策略(8 种 + LRU 近似实现)
- 分布式锁(SETNX + Lua + Redlock + 看门狗)
- 高可用:主从复制 / Sentinel / Cluster
- 大 Key 与热点 Key 问题
- 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 字节)自动转为 哈希表。
💡 小白加餐:先把这几个名词翻译成人话,再往下读(已会请跳过)
💡 类比:IO 多路复用 = 一个前台同时接待 1000 个顾客、谁喊话才应答。银行只有一个前台(单线程),大厅里坐着 1000 个顾客(连接)。 如果前台挨个问「你办好了吗」会累死(轮询),而且一个顾客卡住、其他人都得等(阻塞)。真正高明的做法是:前台记住「谁有事会喊我」, 顾客办完自己举手喊一声,前台才过去——没事的顾客完全不占前台时间。这就是「事件就绪才回调处理」:不是主动去问,而是等对方通知。 Redis 就是用这根「前台」同时盯住几十万连接。
顺带说清 epoll 是什么:它是操作系统提供的一个「事件通知工具」——把要盯的连接交给它,它帮你盯着,哪个连接来了数据就告诉你哪个, 你不用自己一个个查。Linux 上还有更老的 select / poll,epoll 是升级版(支持海量连接、不用反复拷贝名单)。
💡 类比:跳表 = 地铁快慢线 / 电梯直达。普通链表像只有一层的单行线,找 50 号得一间间走(O(N)); 跳表额外修了几条「快速通道」(高层指针),先从高层大步跳到目标附近,再换底层精确到位——先坐快线再换慢线, 查找就从 O(N) 降到 O(log N)。就像电梯直达 30 层、再走一层到 31 层,而不是爬 31 层楼梯。
💡 顺手解释三个名词:
- SDS(简单动态字符串):C 语言的字符串就是一段字符加个结尾标记,想知道多长得从头数(strlen 是 O(n)), 内容里如果碰巧含有结束符还会被截断(缓冲区溢出)。SDS 额外记了一个「长度」字段:查长度 O(1)、存什么都安全。
- 压缩列表(ziplist/listpack):把多个小元素紧紧地排在一块连续内存里,省内存;代价是元素一多操作就变慢, 所以超过阈值(如 512 个 / 64 字节)就自动换成哈希表或跳表。
- dict(哈希表):就是「字典」——按 key 直接算出位置,O(1) 找到 value,像查字典按拼音直接翻到那一页。
1.5 Python 3 可运行示例(redis-py 基本操作)¶
核心概念¶
(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-server):以下代码依赖本机
redis-server(默认 6379 端口)与pip install redis,notebook 中请勿直接运行。
"""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 定义¶
| 问题 | 定义 | 特征 |
|---|---|---|
| 缓存穿透 | 查询根本不存在的 key,缓存和数据库都没有,每次请求都打到 DB | 恶意攻击 / 非法参数,DB 压力大且缓存永远防不住 |
| 缓存击穿 | 一个热点 key 恰好过期,瞬间大量请求同时穿透到 DB | 单个 key 过期瞬间,DB 被打爆 |
| 缓存雪崩 | 大量 key 同时过期(或 Redis 宕机),海量请求直击 DB | 整片缓存失效,DB 雪崩 |
区别一句话:穿透 = 查不到(缓存永远 Miss);击穿 = 热点 key 过期(单个);雪崩 = 大量 key 同时过期 / 服务不可用(批量)。
💡 三个问题的生活版:
- 穿透:坏家伙老拿「查无此人」的假 ID 来查,前台(缓存)每次都跑到里屋(DB)翻一遍——根本没这人,翻也白翻。
- 击穿:最火的柜台(热点 key)恰好歇 1 分钟,所有顾客同时涌向里屋。
- 雪崩:整栋楼的柜台约好同一分钟一起歇(大量 key 同时过期),里屋瞬间被挤爆。
2.2 解决方案对比表¶
| 问题 | 方案 | 说明 |
|---|---|---|
| 穿透 | 布隆过滤器 | 请求前先判「可能存在」,过滤掉不存在 key |
| 穿透 | 缓存空值 + 短过期 | 不存在也缓存 null(TTL 短,如 5 分钟),并加业务兜底 |
| 穿透 | 参数校验 / 限流 | 非法参数直接拒绝(如 id < 0) |
| 击穿 | 互斥锁(Mutex) | 只有一个线程去查 DB 重建缓存,其余等待/降级 |
| 击穿 | 逻辑过期 | key 永不过期,逻辑时间过期后异步重建,请求先返回旧值 |
| 雪崩 | 随机过期时间 | 过期时间加随机抖动(如 ±随机数),错峰失效 |
| 雪崩 | 多级缓存 / 熔断降级 | 本地缓存兜底、限流、开关降级 |
2.3 布隆过滤器原理与公式¶
- 原理:一个 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
💡 类比:布隆过滤器 = 一张「盖了 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)——太小位数组会挤爆、太大浪费内存。
2.4 Python 3 可运行示例(布隆过滤器实现)¶
配图来源:手绘 SVG(images/redis_cache.svg)
# ---- matplotlib 中文字体(防图内中文乱码)----
import matplotlib
matplotlib.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'Songti SC', 'Arial Unicode MS', 'DejaVu Sans']
matplotlib.rcParams['axes.unicode_minus'] = False
# -------------------------------------------
"""纯 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%)")
已插入 1000 个 key user:500 存在? -> True user:9999 存在? -> False 1000 个不存在 key 的误判数 ≈ 10(理论 ~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
"""
'\nSET(key, value) # 永不过期;value 中内嵌逻辑过期时间\nread 时:\n 判断 value.logic_expire < now ?\n 是:返回旧 value,同时后台线程抢锁重建(防止击穿)\n 否:直接返回 value\n'
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 触发方式¶
- 手动:
SAVE(阻塞主线程,生产禁用)/BGSAVE(fork 子进程写快照,不阻塞); - 自动:配置文件
save <seconds> <changes>,如save 900 1(900 秒内 ≥1 次修改)、save 300 10、save 60 10000; - 关闭时:正常
SHUTDOWN会生成 RDB;FLUSHALL等不影响已有文件。
💡 先搞懂 fsync 再读这张表:程序写文件时,数据先进操作系统的一块内存缓存,操作系统「有空了」才真正写入磁盘。 fsync 就是一条命令:请求操作系统立刻把这块缓存真正写到磁盘——写盘完成才放心;没 fsync 时数据还在内存缓存里,一断电就没了。
💡 类比:记账本先记在草稿上,每 1 秒誊写到正式账本。Redis 收到写命令先记在内存(草稿);
everysec= 每隔 1 秒把草稿誊写到正式账本(磁盘)一次。断电时:刚记在草稿上、还没到 1 秒誊写 → 这笔丢了; 誊写完成后 → 不丢。所以「最多丢 1 秒数据」= 最多丢掉最近 1 秒内还没誊写的那几笔。always= 每记一笔立刻誊写(最安全但最慢);no= 交给操作系统自己决定何时写(最快,但断电可能丢比较多)。
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+)¶
- 方案:AOF 重写时生成 RDB 格式的「基础快照」 + 快照之后的新命令追加到 AOF 尾部;
- 收益:加载时先秒级加载 RDB,再重放少量增量命令——兼顾恢复速度与数据安全;
- 配置:
aof-use-rdb-preamble yes。
💡 COW(Copy-On-Write,写时复制)是什么? 复制数据时,一开始只复制目录(页表 / 指针),大家共享同一份数据; 只有某人真要改动某一页时,才把那页真正复制一份给他改——被复制的那一页就叫「写时复制」。
💡 类比:复印整本书 vs 只记改动。BGSAVE 要生成一份快照:如果「复制整本书」→ 内存瞬间翻倍、又慢又贵; COW 的做法是先共看同一本书,谁要改哪页,就只复印那页给谁改。fork 出的子进程看的是「这一刻的书」(快照), 主进程之后每改动一页,那一页才被真正复制——改动越少,额外内存开销越小。 为什么 fork 本身会短暂阻塞?fork 要复制「页表」(相当于把书的目录抄一遍,记录每页在哪)——内存越大目录越长,抄目录越久。 顺带定义 页表:操作系统用来记录「每个内存页在哪、谁在用」的目录。
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 种)¶
| 策略 | 作用域 | 行为 |
|---|---|---|
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。
💡 TTL(Time To Live,生存时间)是什么:给 key 设的「保质期」,过期自动失效(
volatile-ttl就是「谁的保质期先到先扔谁」)。💡 24 位 LRU 时钟是什么:每个 key 记一个「最近一次被访问的时刻」,占 24 位(一个循环刻度)。 内存满时随机抽 5 个 key,把其中「最近访问时刻」最早的淘汰——近似 LRU 不追着全局最旧的找, 而是在小样本里挑最旧的,成本低、效果接近精确 LRU(精确 LRU 要维护双向链表 + 哈希表,代价高)。
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 采样)¶
配图来源:手绘 SVG(images/redis_bloom.svg)
"""标准库实现 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())
精确 LRU 淘汰 -> OrderedDict({'a': 1, 'c': 3})
采样 5 个: [('k16', 28), ('k2', 31), ('k34', 62)] ...
淘汰最久未使用: k16 (lru=28)
近似 LRU 采样淘汰 -> k16
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 释放锁)¶
🔬 示例代码(需在独立环境中运行):以下代码块依赖外部组件/独立进程,在 notebook 中直接执行会失败或挂起,请保存为
.py文件后运行。
"""分布式锁完整示例(需 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("抢锁失败,其他线程持有锁")
💡 类比:分布式锁 = 公共洗手间挂「有人」牌。多个进程抢同一把锁,就像多人排队用同一间洗手间: 谁先挂上「有人」牌(SETNX 成功)谁就用,用完翻牌释放(DEL)。重点是牌子要写名字(value = 唯一标识)—— 只写「有人」的话,A 用完忘翻牌、B 只能用;A 过会儿又回来翻牌,会把 B 正用着的牌子翻掉(误删他人锁)。 所以翻牌前先确认名字是自己(Lua 校验),并对得上才翻。
6.4 看门狗(Watchdog)续期¶
- 问题:业务执行时间超过锁 TTL → 锁提前过期,其他线程抢锁 → 并发执行。
- 方案:看门狗——持有锁期间后台线程周期性(如每 TTL/3)对锁 续期,业务结束释放时取消续期;类比 Redisson 的
watchdog(默认锁 30s,每 10s 续期)。 - 注意:看门狗续期也是「续命」,进程宕机后锁仍会过期(避免死锁)——这是分布式锁「自动失效」特性的价值。
💡 GC 停顿是什么? 很多语言(Java/Go)有自动回收内存的机制(GC),回收时程序会被「暂停一小段时间」 (像打扫房间时全家都得先停下手里的活)。GC 停顿就是这段「被暂停、无法执行代码」的时间。 分布式锁靠「过期时间」兜底:若持锁进程恰好被 GC 停了几十秒,锁在自己不知情时过期,别人就能抢到—— 这正是 Redlock 争议里「GC 停顿导致锁提前失效」的含义。
6.5 Redlock 思想与争议¶
- 思想(Redis 作者提出):在 N 个独立 Redis 节点(通常 5)上都尝试加锁,大多数(N/2+1)成功且总耗时 < TTL 才算加锁成功;释放时对所有节点释放。
- 目的:避免单点 master 故障丢锁后锁失效。
- 争议(Martin Kleppmann 批评):
- 依赖时钟:节点 GC 停顿/时钟跳变会导致锁提前失效或被误判;
- 加锁过程本身不是原子的跨节点事务,存在「加了一半锁进程暂停」的窗口;
- 业界共识:单 Redis + Lua + 看门狗对绝大多数场景足够;追求强一致应改用 ZooKeeper(临时节点 + 顺序节点)/ etcd(租约)。
💡 为什么 Lua 脚本「原子执行」? Redis 单线程执行命令:一条执行完才执行下一条。 Lua 脚本被当成一整段命令提交,执行期间不会插入其他客户端的任何命令——相当于一个服务员一口气把 「先看名字 → 再删锁」做完,中间没人能插队。分开两条命令执行,中间就可能被别人插队(变成误删)。
💡 可重入(Reentrant)锁是什么? 同一个执行者已经持有锁的情况下,还能再次成功获取同一把锁 (锁记一个「重入次数」,每次重入 +1、释放 -1,减到 0 才真正释放)。类比:你进了洗手间又出来拿东西, 认识你的人允许你再进一次。分布式场景用「线程标识 + 计数器」实现(Redisson 支持)。
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)¶
- 全量复制:从节点首次连接 → 主节点
BGSAVE生成 RDB → 传输 RDB → 从节点加载;期间增量命令写入 repl backlog(复制积压缓冲区) 后补发。 - 增量复制:断线重连后,若断点仍在 repl_backlog 中 → 只补发断点后的命令(
PSYNC续传),否则退化为全量复制。 - 角色:一主多从,从节点只读(默认),写命令只在主节点执行。
💡 类比:哨兵 = 保安巡逻队。主节点值班时,几个保安(哨兵进程)轮流确认「主节点还醒着吗」(心跳)。 一个保安说联系不上 = 主观下线(怀疑而已);多数保安都说联系不上 = 客观下线(quorum 确认),才敢换主——避免单个保安看走眼就乱换岗。 换谁当新主,由哨兵们用 Raft 先选出一个「保安队长」来执行。
7.2 哨兵(Sentinel)¶
- 作用:监控(心跳检测主从)、自动故障转移(主节点客观下线 → 选举新主并让从节点切换)、通知(向客户端提供当前主节点地址)。
- 判定:主观下线(单哨兵认为失联)→ 客观下线(quorum 个哨兵都认为失联)→ 选举新主(Raft 选 Leader 哨兵执行切换)。
- 部署:哨兵至少 3 个(奇数,避免脑裂),哨兵之间用 Raft 选主。
💡 Gossip(八卦协议)是什么? 节点之间随机挑几个邻居、把「我知道的消息」讲给他们听,他们再随机讲给别人—— 像办公室里传八卦,不用群发,消息也能很快传遍所有人。Redis Cluster 用 Gossip 互相广播「谁活着、槽位在哪」, 槽位消息是位图(约 2KB),所以槽越多、心跳包越大(这就是追问 3 里 16384 而不是 65536 的原因之一)。
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:槽在迁移中 → 临时重定向,客户端不更新缓存(迁移完成前仍需回原节点确认)。
- MOVED:key 的槽在其他节点 → 客户端收到
- 容灾:每个主节点配从节点,主挂从顶上(选举提升)。
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)
key=user:1001 slot=5712
key=cart:2002 slot=9557
key={user:1}:info slot=10778
key={user:1}:cart slot=10778
槽 1234 已迁移到 10.0.0.2:6379,更新本地路由缓存并重试
槽 1234 正在迁移,向 10.0.0.3:6379 发 ASKING 后重试(不更新缓存)
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)¶
🔬 示例代码(需 redis-server):用 SCAN 分批删除大 Hash 字段,依赖本机 Redis 服务,notebook 中请勿直接运行。
"""用 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-八股与工程/。
10. 扩展专题:面试加分项(10.1 – 10.22)¶
本专题覆盖:单线程模型深入、命令速查、跳表 / 计数布隆 / LFU 代码、缓存策略与竞态推演、 高可用架构、事务 / 管道 / Lua、限流、排行榜 / 延时队列、HLL、文件格式、内存优化、排查与高频 10 问。 全部代码纯标准库、零依赖、可直接运行。
10.1 单线程模型深入:为什么快 + 为什么坚持单线程(4 点)¶
- IO 多路复用(epoll):单线程同时监听海量 socket,只有事件就绪才回调处理——把「等待 IO」变成「事件驱动」,不会阻塞在任何一个连接上;
- 纯内存 + 高效数据结构:读写内存为纳秒级,SDS / 跳表 / 压缩列表把命令复杂度压到 O(1) / O(log N);
- 无锁、无上下文切换:单线程执行命令,天然规避锁竞争、线程切换、CPU 缓存失效;
- 为什么不用多线程执行命令:命令本身微秒级,瓶颈在网络 IO 与内存带宽,多线程只会引入锁与一致性复杂度;Redis 6.0 的「多线程」只用于 socket 读写编解码,命令执行仍是单线程。
⚠️ 易错点:真正拖慢单线程的是 O(N) 危险命令(
KEYS *、大 key 的HGETALL/SMEMBERS)—— 面试答「单线程慢」会扣分,正确姿势是答「单线程 + 防慢查询」。
💡 10.1 呼应第 1 节的小白类比:IO 多路复用 = 一个前台接待 1000 个顾客、谁喊话才应答(epoll 帮你盯着哪个连接来数据了再通知你)。 «把等待 IO» 变成 «事件驱动» 这句话可以记成:不是前台一个个去问,而是顾客举手才过去——空闲连接完全不占时间。
10.2 五种结构命令速查表(含时间复杂度)¶
| 结构 | 核心命令 | 复杂度要点 | 高频考点 |
|---|---|---|---|
| String | SET / GET / MSET / INCR / SETNX / SETEX |
GET/SET O(1) | INCR 原子;SETNX 抢锁 |
| List | LPUSH / RPOP / LRANGE / LINDEX / BLPOP |
首尾 O(1),中间 O(N) | BLPOP 阻塞队列 |
| Hash | HSET / HGET / HMSET / HINCRBY / HSCAN |
单字段 O(1) | HINCRBY 原子改字段 |
| Set | SADD / SISMEMBER / SPOP / SINTER / SSCAN |
单元素 O(1) | SINTER 共同关注 |
| ZSet | ZADD / ZINCRBY / ZRANGE / ZREVRANGE / ZSCORE / ZRANGEBYSCORE |
增删查 O(log N) | 排行榜、延时队列 |
通用命令:EXPIRE / TTL / DEL / UNLINK / TYPE / EXISTS / SCAN(SCAN 游标遍历,替代 KEYS *)。
⚠️ 易错点:
ZSCORE因 dict 辅助索引是 O(1),但ZRANGE是 O(log N + M);LRANGE取中间段是 O(N)——大 List 慎用。
10.3 跳表(skiplist)实现——「快线 + 慢线」的代码版¶
呼应 1.4 的类比:跳表 = 地铁快慢线。下面代码演示插入后如何保持有序、如何 O(log N) 查找, 以及「随机层级」如何自然形成高层快线(1/2 概率升级 = 越往上越稀疏)。
"""Redis ZSet 底层之一:跳表(skiplist)简化实现(纯标准库,可直接运行)。
演示插入后有序、查找、以及随机层级结构。"""
import random
class Node:
__slots__ = ('val', 'forwards')
def __init__(self, val, level):
self.val = val
self.forwards = [None] * level # 每层指向下一个节点
class SkipList:
"""最简跳表:整数升序 + 随机层级(1/2 概率升级)。"""
MAX_LEVEL = 16
def __init__(self):
self.head = Node(-1, self.MAX_LEVEL)
self.level = 1
self.count = 0
def _random_level(self):
lv = 1
while lv < self.MAX_LEVEL and random.random() < 0.5:
lv += 1
return lv
def insert(self, val):
update = [None] * self.MAX_LEVEL
cur = self.head
for i in range(self.level - 1, -1, -1): # 自顶向下找插入位置
while cur.forwards[i] and cur.forwards[i].val < val:
cur = cur.forwards[i]
update[i] = cur
lv = self._random_level()
if lv > self.level: # 新层级补指向 head
for i in range(self.level, lv):
update[i] = self.head
self.level = lv
node = Node(val, lv)
for i in range(lv):
node.forwards[i] = update[i].forwards[i]
update[i].forwards[i] = node
self.count += 1
def search(self, val):
cur = self.head
for i in range(self.level - 1, -1, -1):
while cur.forwards[i] and cur.forwards[i].val < val:
cur = cur.forwards[i]
nxt = cur.forwards[0]
return nxt is not None and nxt.val == val
def to_list(self):
out, cur = [], self.head.forwards[0]
while cur:
out.append(cur.val)
cur = cur.forwards[0]
return out
def top_chain(self):
"""最高层指针链(演示「跳跃」的层级索引)。"""
out, cur = [], self.head.forwards[self.level - 1]
while cur:
out.append(cur.val)
cur = cur.forwards[self.level - 1]
return out
if __name__ == '__main__':
random.seed(42)
sl = SkipList()
for v in [3, 6, 9, 2, 8, 5, 1]:
sl.insert(v)
print("插入后有序序列:", sl.to_list())
print("实际层高:", sl.level)
print("最高层索引链(跳过的元素):", sl.top_chain())
for v in (5, 7):
print(f"查找 {v}:", sl.search(v))
print("节点数:", sl.count)
插入后有序序列: [1, 2, 3, 5, 6, 8, 9] 实际层高: 5 最高层索引链(跳过的元素): [8] 查找 5: True 查找 7: False 节点数: 7
10.4 计数布隆过滤器(CBF)实现——支持删除的布隆¶
标准布隆不能删(把某一位改成 0 可能误伤共用这一位的其他元素)。计数版把每个「位」升级成「计数器」: 添加 +1、删除 -1、查询看是否 >0——代价是空间更大(真实实现用 4 bit 计数器)。
"""计数布隆过滤器(Counting Bloom Filter):支持删除(纯标准库,可直接运行)。
标准布隆过滤器无法删除元素(删除一个位会影响其他元素),CBF 用计数器数组实现删除。"""
import hashlib
import math
class CountingBloomFilter:
def __init__(self, n=1000, p=0.01):
self.m = max(8, int(-n * math.log(p) / (math.log(2) ** 2)))
self.k = max(1, int(self.m / n * math.log(2)))
self.counters = [0] * self.m # 计数器数组(真实实现用 4 bit 计数器)
def _hashes(self, item):
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):
for idx in self._hashes(item):
self.counters[idx] += 1
def remove(self, item):
for idx in self._hashes(item):
if self.counters[idx] > 0:
self.counters[idx] -= 1
def contains(self, item):
return all(self.counters[idx] > 0 for idx in self._hashes(item))
if __name__ == '__main__':
cbf = CountingBloomFilter(n=1000, p=0.01)
keys = [f'k{i}' for i in range(500)]
for k in keys:
cbf.add(k)
print("添加 500 个 key 后, k100 存在?", cbf.contains('k100'))
cbf.remove('k100')
print("删除 k100 后存在?", cbf.contains('k100'))
# 删除只影响自身,其余 key 仍可查询(可能存在少量共享计数器衰减,概率极低)
ok = sum(cbf.contains(k) for k in keys if k != 'k100')
print(f"删除后其余 499 个 key 仍存在: {ok}/499")
# 与标准布隆过滤器对比误判率
fp = sum(cbf.contains(f'junk{i}') for i in range(2000))
print(f"2000 个不存在 key 的误判数 ≈ {fp}(计数版与标准版误判率相当)")
添加 500 个 key 后, k100 存在? True 删除 k100 后存在? False 删除后其余 499 个 key 仍存在: 499/499 2000 个不存在 key 的误判数 ≈ 0(计数版与标准版误判率相当)
10.5 缓存更新策略四件套 + 「先删 vs 先更」竞态¶
| 策略 | 读 | 写 | 特点 |
|---|---|---|---|
| Cache-Aside(旁路) | 缓存未命中 → 查 DB → 回填 | 先更 DB 再删缓存 | 主流;最终一致,需防并发回填旧值 |
| Read-Through | 未命中 → 缓存组件代查 DB 并回填 | 同上(由缓存组件封装) | 客户端无感知,逻辑集中在缓存侧 |
| Write-Through(写穿透) | 同上 | 先写缓存,缓存组件同步写 DB | 缓存与 DB 同步一致,但每次写双倍延迟 |
| Write-Behind(写回) | 同上 | 只写缓存,异步批量刷 DB | 吞吐最高;宕机可能丢数据,需 MQ 兜底 |
「先删缓存再更库」vs「先更库再删缓存」竞态推演(10.6 代码会模拟):
| 时序方案 | 竞态窗口 | 结果 |
|---|---|---|
| 先删缓存 → 写库 | 删后、写库前有读 → 读 DB 旧值回填 | 缓存长期旧值,不一致难收敛 |
| 先写库 → 删缓存 | 写后、删前有读 → 返回缓存旧值 | 短暂旧值,删后自愈(可接受) |
| 先写库 → 删缓存 → 延时再删(延时双删) | 覆盖「读旧值回填」窗口 | 窗口最小,工程标配 |
| 版本号 / CAS | 回填时带版本号,旧版本不覆盖 | 从根上消除旧值回填 |
⚠️ 易错点:「删缓存」失败是不一致的主因——必须配 MQ / binlog 重试兜底; 方案再完美,删除动作丢了等于白搭(呼应第 3 节)。
10.6 「先删 vs 先更」竞态推演代码——眼见为实¶
把第 3 节的「竞态窗口」用代码演一遍:读请求恰好插在删除与写库之间时,会发生什么。 结论先剧透:先删缓存 → 旧值回填难自愈;先更库 → 短暂旧值可自愈。
"""模拟「先删缓存 vs 先更库」在并发读窗口下的结果差异(纯事件推演,可直接运行)。
一致性问题的根源:缓存删除与 DB 更新不是原子的,中间插入的读请求可能「回填旧值」。"""
def run_case(strategy, reader_between=True):
db, cache = 10, 10 # 初始:DB=10,缓存已预热=10
print(f"== 策略【{strategy}】 初始 DB={db}, 缓存={cache} ==")
if strategy == 'del_first':
cache = None
print(" ① 写方: DEL cache")
if reader_between:
cache = db # 读方此时读到 DB 旧值 10 并回填
print(" ② 读方: 缓存未命中 -> 读 DB(=10) -> 回填缓存=10")
db = 20
print(" ③ 写方: UPDATE DB=20")
else:
db = 20
print(" ① 写方: UPDATE DB=20")
if reader_between:
print(" ② 读方: 命中缓存旧值 10(短暂读到旧值)")
cache = None
print(" ③ 写方: DEL cache")
print(f" 结果: DB={db}, 缓存={cache}")
if cache is not None and cache != db:
print(" → ❌ 缓存长期为旧值,不一致难自愈")
else:
print(" → ✅ 删除后读方会回填新值,最终一致")
print()
if __name__ == '__main__':
run_case('del_first')
run_case('db_first')
print("补充: 先更库 + 延时双删 —— 第二次删除覆盖「回填旧值」窗口,")
print("缓存最终为空,下次读必然回填新值(代码见第 3 节 redis-py 版本)。")
== 策略【del_first】 初始 DB=10, 缓存=10 == ① 写方: DEL cache ② 读方: 缓存未命中 -> 读 DB(=10) -> 回填缓存=10 ③ 写方: UPDATE DB=20 结果: DB=20, 缓存=10 → ❌ 缓存长期为旧值,不一致难自愈 == 策略【db_first】 初始 DB=10, 缓存=10 == ① 写方: UPDATE DB=20 ② 读方: 命中缓存旧值 10(短暂读到旧值) ③ 写方: DEL cache 结果: DB=20, 缓存=None → ✅ 删除后读方会回填新值,最终一致 补充: 先更库 + 延时双删 —— 第二次删除覆盖「回填旧值」窗口, 缓存最终为空,下次读必然回填新值(代码见第 3 节 redis-py 版本)。
10.7 LFU vs LRU 实现对比——「用得少不少」vs「多久没用」¶
LRU 看「多久没用」,LFU 看「用得少不少」。代码演示「突发访问」下两者淘汰结果不同: 一个偶尔被访问的热点,LRU 可能误杀,LFU 会记住它的历史高频而保留。
"""LFU(最不经常使用)与 LRU(最近最少使用)实现对比(纯标准库,可直接运行)。
Redis 4.0+ 的 allkeys-lfu 是「对数衰减频次」的近似;这里给出可读的精确版理解实现。"""
from collections import OrderedDict
class ExactLRU:
"""精确 LRU:OrderedDict 的 move_to_end 即「最近使用」。"""
def __init__(self, cap):
self.cap = cap
self.d = OrderedDict()
def get(self, k):
if k not in self.d:
return None
self.d.move_to_end(k)
return self.d[k]
def set(self, k, v):
if k in self.d:
self.d.move_to_end(k)
self.d[k] = v
if len(self.d) > self.cap:
self.d.popitem(last=False) # 淘汰最久未使用
def keys(self):
return list(self.d.keys())
class LFUCache:
"""精确 LFU:按 (频次, 最近使用序) 淘汰——频次低的先淘汰,同频次淘汰更早的。"""
def __init__(self, cap):
self.cap = cap
self.data = {} # k -> v
self.freq = {} # k -> 访问频次
self.last = {} # k -> 最近访问序(同频次 FIFO)
self.clock = 0
def get(self, k):
if k not in self.data:
return None
self.freq[k] += 1
self.last[k] = self.clock
self.clock += 1
return self.data[k]
def set(self, k, v):
if k in self.data:
self.data[k] = v
self.freq[k] += 1
else:
if len(self.data) >= self.cap: # 淘汰频次最低(且最早使用)的
victim = min(self.data, key=lambda x: (self.freq[x], self.last[x]))
del self.data[victim]
del self.freq[victim]
del self.last[victim]
self.data[k] = v
self.freq[k] = 1
self.last[k] = self.clock
self.clock += 1
def keys(self):
return sorted(self.data, key=lambda x: (self.freq[x], self.last[x]))
if __name__ == '__main__':
lru, lfu = ExactLRU(3), LFUCache(3)
# 访问序列:a 在早期访问 3 次,随后 b 连续访问 100 次,c 只访问 1 次
for k in 'abc':
lru.set(k, 1)
lfu.set(k, 1)
for _ in range(3):
lru.get('a')
lfu.get('a')
for _ in range(100):
lru.get('b')
lfu.get('b')
lru.get('c')
lfu.get('c')
# 缓存满,再写入 d 触发淘汰
lru.set('d', 1)
lfu.set('d', 1)
print("LRU 淘汰后剩余:", sorted(lru.keys()), "(淘汰 a:最久未使用)")
print("LFU 淘汰后剩余:", sorted(lfu.keys()), "(淘汰 c:访问频次最低;a 因历史高频被保留)")
print("结论: LFU 抵抗『突发访问』对历史热点的误杀,适合低频热点常驻场景")
LRU 淘汰后剩余: ['b', 'c', 'd'] (淘汰 a:最久未使用) LFU 淘汰后剩余: ['a', 'b', 'd'] (淘汰 c:访问频次最低;a 因历史高频被保留) 结论: LFU 抵抗『突发访问』对历史热点的误杀,适合低频热点常驻场景
10.8 单机 / 主从 / Sentinel / Cluster 四层架构对比¶
| 维度 | 单机 | 主从复制 | Sentinel 哨兵 | Cluster 集群 |
|---|---|---|---|---|
| 数据分片 | 无 | 无(全量复制) | 无 | 16384 槽分片 |
| 自动故障转移 | 无(宕机即不可用) | 手动(或靠哨兵) | 自动(Raft 选主切换) | 自动(从节点选举提升) |
| 横向扩展 | 不可 | 读写分离(从节点读) | 基本不可(写仍单点) | 可(加节点迁移槽位) |
| 复杂度 | 最低 | 低 | 中(3+ 哨兵进程) | 高(槽位 / Gossip / 重定向) |
| 适用场景 | 开发测试、小容量 | 冷备 + 读扩展 | 中小规模高可用 | 大规模高并发 + 高可用 |
选型一句话:
- 数据量小、可容忍短不可用 → 单机;
- 要备份 / 读写分离 → 主从;
- 要自动故障转移、量级不大 → Sentinel(一般同时开主从);
- 数据量大、QPS 高 → Cluster(官方推荐大规模场景)。
⚠️ 易错点:Sentinel 只解决高可用(故障转移),不解决容量扩展; Cluster 两者兼得,但不支持跨槽多 key 事务/管道(需 hash tag)——「Sentinel 上自己做分片」属于中间态方案。
10.9 Redis 事务(MULTI/EXEC)vs Pipeline vs Lua 脚本¶
| 特性 | 事务 MULTI/EXEC | Pipeline(管道) | Lua 脚本 |
|---|---|---|---|
| 命令原子性 | 不保证(中途出错不回滚已执行命令) | 不保证 | 保证(整段脚本原子执行) |
| 网络往返 | 每命令一次(可配 pipeline 优化) | 一次发送一批 | 一次发送脚本 |
| 条件逻辑 | 无(靠 WATCH + 重试 实现 CAS) | 无 | 原生支持 if/while |
| 典型场景 | 多条命令连续执行、中间不被插入 | 高并发批量读写(省 RTT) | 复杂原子逻辑(释放锁、扣库存) |
怎么选:
- 只要「一起发、不被打断」→ MULTI/EXEC(或 Lua);
- 只要「少几次网络往返」→ Pipeline;
- 需要「原子 + 条件判断」→ Lua(Redis 官方推荐,如秒杀扣库存、释放锁校验)。
⚠️ 易错点:MULTI/EXEC 不是传统事务——Redis 事务「出错不回滚」; Pipeline 只是客户端优化(服务端仍串行处理),两者都与原子性无关。
10.10 WATCH 乐观锁(CAS)模拟——先比后改¶
呼应 9.1 的 CAS:WATCH 监视 key,事务(MULTI/EXEC)期间 key 被改则 EXEC 返回失败、客户端重试。 代码用「值是否变化」模拟 WATCH 检测,演示「并发扣款导致事务中止」与「重试成功」。
"""用 WATCH + MULTI/EXEC 实现乐观锁(CAS)语义的简化模拟(纯标准库,可直接运行)。
真实场景:WATCH balance -> GET balance -> MULTI -> DECR -> EXEC,
若 WATCH 期间 key 被修改,EXEC 返回 nil,客户端需重试。"""
def execute_tx(balance, concurrent_deduct=0):
"""模拟 WATCH balance 后的事务;并发扣减会让 WATCH 检测到修改而中止。"""
watched = balance # WATCH 时刻的版本(以值为版本)
balance -= concurrent_deduct # 事务排队期间其他客户端完成的操作
if watched != balance: # EXEC 前检测到修改 -> 事务失败(nil 语义)
return 'ABORT', balance
balance -= 1 # 事务内的 DECRBY 1(扣款成功)
return 'COMMIT', balance
if __name__ == '__main__':
balance = 100
print("== 场景一:无并发修改 ==")
status, balance = execute_tx(balance)
print(f" {status}: 扣款成功, 余额={balance}")
print("== 场景二:事务期间有并发扣款 10 元 ==")
status, balance = execute_tx(balance, concurrent_deduct=10)
print(f" {status}: EXEC 返回 nil, 余额={balance}(WATCH 检测到修改)")
print("== 场景三:客户端重试(重新 WATCH 后再次执行)==")
status, balance = execute_tx(balance)
print(f" {status}: 重试成功, 余额={balance}")
== 场景一:无并发修改 == COMMIT: 扣款成功, 余额=99 == 场景二:事务期间有并发扣款 10 元 == ABORT: EXEC 返回 nil, 余额=89(WATCH 检测到修改) == 场景三:客户端重试(重新 WATCH 后再次执行)== COMMIT: 重试成功, 余额=88
10.11 四种限流算法对比¶
| 算法 | 思路 | 优点 | 缺点 | 典型 Redis 实现 |
|---|---|---|---|---|
| 固定窗口 | 每秒/每分钟计数,超阈值拒绝 | 简单 | 临界突刺(窗口边界双倍通过) | INCR key + EXPIRE |
| 滑动窗口 | 记录窗口内每个请求时间戳 | 无临界突刺 | 内存随请求量增长(可用采样优化) | ZADD + ZREMRANGEBYSCORE + ZCARD |
| 令牌桶 | 恒速放令牌,取到才放行 | 允许一定突发(桶容量),平滑 | 实现略复杂 | Lua 维护 token + last_refill |
| 漏桶 | 请求进桶,恒速流出 | 输出速率严格恒定,抗突发 | 突发请求延迟高 | 队列 + 消费速率控制 |
面试一句话:实时流控追求平滑 → 令牌桶;严格限速(短信)→ 漏桶;简单计数可接受毛刺 → 固定窗口 + 随机抖动。
10.12 限流算法实现代码——固定 / 滑动 / 令牌桶对比¶
10.11 讲四种算法,这里把三种用代码跑给你看:同一批「1 秒内 10 个突发请求」,谁的放行曲线更平滑。 你会发现固定窗口在窗口边缘「双倍通过」,令牌桶攒了令牌可以短时放行更多。
"""固定窗口 / 滑动窗口 / 令牌桶 三种限流算法模拟(纯标准库、模拟时钟,可直接运行)。"""
from collections import deque
class FixedWindow:
"""固定窗口:窗口内计数,超限拒绝;窗口切换即重置。"""
def __init__(self, limit=5, window=10.0):
self.limit, self.window = limit, window
self.count, self.win_start = 0, 0.0
def allow(self, now):
if now - self.win_start >= self.window: # 进入新窗口
self.win_start, self.count = now, 0
if self.count >= self.limit:
return False
self.count += 1
return True
class SlidingWindow:
"""滑动窗口:保留窗口内每个请求时间戳,淘汰窗口外旧戳。"""
def __init__(self, limit=5, window=10.0):
self.limit, self.window = limit, window
self.q = deque()
def allow(self, now):
while self.q and now - self.q[0] >= self.window:
self.q.popleft()
if len(self.q) >= self.limit:
return False
self.q.append(now)
return True
class TokenBucket:
"""令牌桶:按速率补令牌(最多到容量),有令牌才放行。"""
def __init__(self, capacity=8, rate=1.0):
self.cap, self.rate = capacity, rate
self.tokens, self.last = capacity, 0.0
def allow(self, now):
self.tokens = min(self.cap, self.tokens + (now - self.last) * self.rate)
self.last = now
if self.tokens < 1:
return False
self.tokens -= 1
return True
if __name__ == '__main__':
fw, sw, tb = FixedWindow(5, 10), SlidingWindow(5, 10), TokenBucket(8, 1.0)
# 模拟:1 秒内 10 个突发请求,第 11 秒再来 3 个
timestamps = [1.0 + i * 0.1 for i in range(10)] + [11.0, 11.1, 11.2]
print("t 固定窗口 滑动窗口 令牌桶")
for t in timestamps:
print(f"{t:5.1f} {'放行' if fw.allow(t) else '拒绝'} "
f"{'放行' if sw.allow(t) else '拒绝'} "
f"{'放行' if tb.allow(t) else '拒绝'}")
t 固定窗口 滑动窗口 令牌桶 1.0 放行 放行 放行 1.1 放行 放行 放行 1.2 放行 放行 放行 1.3 放行 放行 放行 1.4 放行 放行 放行 1.5 拒绝 拒绝 放行 1.6 拒绝 拒绝 放行 1.7 拒绝 拒绝 放行 1.8 拒绝 拒绝 拒绝 1.9 拒绝 拒绝 拒绝 11.0 放行 放行 放行 11.1 放行 放行 放行 11.2 放行 放行 放行
10.13 ZSet 排行榜模拟——ZADD / ZINCRBY / ZREVRANGE / ZSCORE¶
直播打赏榜场景:member = 用户、score = 打赏金额。代码演示加分(ZINCRBY)、降序排名(ZREVRANGE)、 分数区间查询(ZRANGEBYSCORE)——这是 Redis 排行榜的标准姿势。
"""用 Python 模拟 Redis ZSet 排行榜核心操作(ZADD/ZINCRBY/ZREVRANGE/ZSCORE),
纯标准库、可直接运行(对应直播打赏榜场景)。"""
import bisect
class ZSet:
"""简化 ZSet:有序列表 (score, member) 升序 + dict 按 member 查 score。"""
def __init__(self):
self.member_score = {}
self.sorted_pairs = []
def add(self, member, score):
if member in self.member_score:
self.sorted_pairs.remove((self.member_score[member], member))
self.member_score[member] = score
bisect.insort(self.sorted_pairs, (score, member))
def incr(self, member, delta):
"""等价 ZINCRBY。"""
cur = self.member_score.get(member, 0)
self.add(member, cur + delta)
def score(self, member):
return self.member_score.get(member)
def zrevrange(self, start, stop):
"""降序取 [start, stop],支持负数索引(如 0,-1 取全部)。"""
pairs = list(reversed(self.sorted_pairs))
n = len(pairs)
if start < 0:
start = max(0, n + start)
if stop < 0:
stop = n + stop
return [m for _, m in pairs[start:stop + 1]]
def zrangebyscore(self, lo, hi):
return [m for s, m in self.sorted_pairs if lo <= s <= hi]
if __name__ == '__main__':
z = ZSet()
for name, sc in [('alice', 100), ('bob', 50), ('carol', 80), ('dave', 60)]:
z.add(name, sc)
print("完整排名(降序):", z.zrevrange(0, -1))
z.incr('bob', 45) # bob 打赏 45:50 -> 95
print("bob 打赏 45 后排名:", z.zrevrange(0, -1))
print("Top2:", z.zrevrange(0, 1))
print("分数区间 [60, 90]:", z.zrangebyscore(60, 90))
print("alice 当前分数:", z.score('alice'))
完整排名(降序): ['alice', 'carol', 'dave', 'bob'] bob 打赏 45 后排名: ['alice', 'bob', 'carol', 'dave'] Top2: ['alice', 'bob'] 分数区间 [60, 90]: ['dave', 'carol'] alice 当前分数: 100
10.14 ZSet 延时队列模拟——score = 到期时间戳¶
把「到期时间」当分数存进 ZSet,每轮取出分数最小(最早到期)且已到期的任务执行—— 订单超时未支付自动取消、优惠券到期提醒都是这个套路(member = 任务 ID,score = 到期时间戳)。
"""用 ZSet 模拟 Redis 延时队列:member=任务ID, score=到期时间戳。
到期任务用 ZRANGEBYSCORE(-inf, now) + ZREM 取出执行(纯标准库,可直接运行)。"""
import time
class DelayQueue:
def __init__(self):
self.tasks = {} # task_id -> 到期时间戳
self.sorted_tasks = [] # [(deadline, task_id)] 升序
def push(self, task_id, delay_s):
"""delay_s 秒后到期(等价 ZADD score=now+delay)。"""
deadline = time.monotonic() + delay_s
self.tasks[task_id] = deadline
self.sorted_tasks.append((deadline, task_id))
self.sorted_tasks.sort()
def poll(self):
"""取回所有到期任务(等价 ZRANGEBYSCORE -inf now + ZREM)。"""
now = time.monotonic()
ready = []
while self.sorted_tasks and self.sorted_tasks[0][0] <= now:
_, tid = self.sorted_tasks.pop(0)
self.tasks.pop(tid, None)
ready.append(tid)
return ready
def size(self):
return len(self.tasks)
if __name__ == '__main__':
q = DelayQueue()
t0 = time.monotonic()
q.push('order:1:pay_timeout', 0.3) # 0.3 秒后到期
q.push('order:2:pay_timeout', 0.6)
q.push('order:3:pay_timeout', 0.1)
print("任务数:", q.size())
for wait in (0.2, 0.3, 0.4):
time.sleep(wait) # 总 sleep 0.9s < 5s
due = q.poll()
if due:
print(f"t+{time.monotonic() - t0:.1f}s 到期任务: {due}")
print("剩余任务数:", q.size())
任务数: 3
t+0.2s 到期任务: ['order:3:pay_timeout']
t+0.5s 到期任务: ['order:1:pay_timeout']
t+0.9s 到期任务: ['order:2:pay_timeout'] 剩余任务数: 0
10.15 Bitmap 与 HyperLogLog:空间换精度的艺术¶
Bitmap(位图):用 1 bit 表示一个状态(签到、在线、去重)。命令 SETBIT / GETBIT / BITCOUNT。
- 例:1 亿用户签到只需
1e8 bit = 12.5 MB;BITCOUNT复杂度 O(位数/8)。
HyperLogLog(HLL):统计**基数(不重复元素个数)**的概率数据结构:
- 原理:哈希后看二进制前导 0 的个数——前导 0 越多说明该哈希「越稀有」,用极值对数估计基数;
- 改进:分 m 个寄存器取调和平均(随机平均),命令
PFADD / PFCOUNT / PFMERGE; - 误差约 0.81%(
1.04/√m),Redis 实现固定 12KB,可统计 2^64 量级基数。
标准误差 ≈ 1.04 / √m (m = 寄存器数量)
示例:m=1024 -> 约 3.3%;Redis 固定 m=16384 -> 约 0.81%
💡 先懂直觉:抛硬币连抛几次「反面」。拿一枚普通硬币抛,记录「连续出现反面的次数」: 一抛就出正面 → 连续反面 0 次;连抛 3 次才出正面 → 连续反面 2 次。直觉:连续反面次数越多,说明这一轮抛的次数越多 (出现「连续 5 次反面」比「连续 1 次反面」稀有得多)。
把「抛硬币」换成「算哈希」:每个元素哈希成 64 位二进制,开头连续 0 的个数(前导 0)就等价于「连续反面的次数」。 前导 0 越多 → 这个哈希越稀有 → 说明我们见过的不同元素越多(见得多,才更可能撞见这么稀有的哈希)。
三步推演:① 每来一个元素,算哈希、数它前导 0 的个数 r;② 全程只记住「每个位置见过的最大的 r」; ③ 用最大的 r 反推:见过多少个不同元素才可能产生这么长的前导 0?≈ 2^r。
为什么分 m 个寄存器(register)? 只记一个最大值容易被运气带偏(碰巧一次撞到超长前导 0 就高估)。 把哈希分成 m 组,每组各记各的最大值(每个组就是一个«寄存器»),最后用调和平均合并—— 调和平均对「个别离谱的大值」不敏感(它怕小值、不怕大值),让估计更稳。 Linear Counting 是低基数修正:元素很少时大多数寄存器还是 0,直接按 2^r 算会偏大,改用「空寄存器比例」反推 (空得越多 → 元素越少)——10.16 代码里实现了它。
数字例子:插入 20000 个不重复 ID,用 m=1024 个寄存器(p=10)估计,误差约 3%——告诉你「大概 20000」而不是精确值。 UV 统计要的就是「量级对、内存省」(12KB 就能估 2^64 量级)。
使用场景:UV 统计(亿级日活)、去重计数(点击/搜索词)、AB 实验指标——不要求精确、只求量级。
⚠️ 易错点:HLL 只能插入、不能删除;低基数时需小范围修正(Linear Counting), 面试说出「小范围修正 + 大范围饱和修正」是加分项(10.16 代码实现了小范围修正)。
10.16 HyperLogLog 实现与误差验证——「抛硬币」的代码版¶
呼应 10.15 的硬币类比:代码演示插入 20000 个不重复元素后估计基数、误差约 3%, 以及「重复插入不改变估计」(HLL 幂等)——UV 统计就是靠它省内存。
"""
HyperLogLog 简化实现(纯标准库,可直接运行):演示基数估计与理论误差。
原理:64 位哈希,前 p 位定寄存器,剩余位统计「前导零个数+1」;
多个寄存器调和平均后乘以修正系数 alpha_m;低基数用 Linear Counting 修正。
"""
import hashlib
import math
class HyperLogLog:
def __init__(self, p=10):
self.p = p
self.m = 1 << p # 寄存器数量 2^p
self.regs = [0] * self.m
self.alpha = 0.7213 / (1 + 1.079 / self.m)
def _hash64(self, item):
return int(hashlib.md5(str(item).encode()).hexdigest()[:16], 16)
def add(self, item):
h = self._hash64(item)
idx = h & (self.m - 1) # 前 p 位 -> 寄存器下标
rest = h >> self.p # 剩余 64-p 位
rank = (64 - self.p) - rest.bit_length() + 1 # 前导零个数 + 1
self.regs[idx] = max(self.regs[idx], rank)
def count(self):
inv = sum(2.0 ** (-r) for r in self.regs)
est = self.alpha * self.m * self.m / inv
# 小范围修正:Linear Counting(V = 零寄存器个数)
if est <= 2.5 * self.m:
v = self.regs.count(0)
if v > 0:
est = self.m * math.log(self.m / v)
return est
if __name__ == '__main__':
hll = HyperLogLog(p=10) # m=1024,理论误差约 3.3%
N = 20000
for i in range(N):
hll.add(f'uv:{i}')
est = hll.count()
print(f"插入 {N} 个不重复元素 -> 估计基数 {est:.0f}, 误差 {abs(est - N) / N * 100:.2f}%")
# 重复插入不改变估计(HLL 幂等)
for i in range(N):
hll.add(f'uv:{i}')
print(f"重复插入一次后估计仍为 {hll.count():.0f}(HLL 幂等)")
插入 20000 个不重复元素 -> 估计基数 19061, 误差 4.70% 重复插入一次后估计仍为 19061(HLL 幂等)
10.17 RDB 与 AOF 文件格式示意¶
RDB(二进制快照)——头部几个字节示意:
52 45 44 49 53 30 30 31 31 「REDIS0011」版本号
FA 09 72 65 64 69 73 2D 76 65 72 AUX 字段: redis-ver=...
FE 00 DB 编号 0
FB 02 00 00 RESIZEDB: 哈希表大小
00 C0 01 61 key="a" -> 整数值 1(int 编码)
...
FF EOF 标记
AOF(追加命令日志)——RESP 协议文本格式,每行一条命令:
*3\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n
*2\r\n$6\r\nSELECT\r\n$1\r\n0\r\n
解读:
*N表示后面有 N 个参数;$len表示下一个参数的字节长度;\r\n分隔。 AOF 重写把多条命令合并为最少命令集(如 100 次 INCR 合并成一条SET 100),文件大幅缩小。
⚠️ 易错点:RDB 是二进制快照(人类不可读),AOF 是RESP 命令流(可读)—— 面试描述「RDB 是文本文件」会被判定为不懂。
10.18 内存优化与编码转换阈值¶
Redis 对象编码(内存优化的关键):
| 结构 | 小数据编码 | 大数据编码 | 转换阈值(默认) |
|---|---|---|---|
| String | int(整型复用)/ embstr | raw | ≤44B 用 embstr(一次分配、连续内存) |
| Hash | listpack(ziplist) | hashtable | 元素数 >512 或 单元素 >64B |
| List | quicklist(ziplist 节点) | quicklist | 节点内 ziplist ≤8KB(list-max-ziplist-size 可配) |
| Set | intset(有序整型数组) | hashtable | 全为整数且元素数 >512 |
| ZSet | listpack(ziplist) | skiplist + dict | 元素数 >128 或 单元素 >64B |
内存排查命令:
MEMORY USAGE key:单个 key 的内存;MEMORY STATS:内存统计;INFO memory:看used_memory与mem_fragmentation_ratio(碎片率 >1.5 说明碎片多,可重启或开activedefrag);- 大 value 用压缩(gzip)+ 拆 key;纯整数用 int 编码省一半内存。
⚠️ 易错点:整型 String(int 编码)不占额外字符串对象; 「ZSet 元素少时用 listpack、多时用 skiplist」——512 / 64 / 128 三个阈值数字是常考点。
10.19 线上排查命令速查¶
| 命令 | 用途 | 示例 |
|---|---|---|
redis-cli --bigkeys |
扫描大 key(按类型分组给最大 key) | redis-cli --bigkeys |
redis-cli --hotkeys |
扫描热点 key(需配置 LFU) | redis-cli --hotkeys |
SLOWLOG GET 10 |
查看慢查询(超过阈值的命令) | 定位大 key 的 O(N) 操作 |
MONITOR |
实时打印所有命令(生产慎用,性能开销大) | 抓可疑请求 |
INFO |
内存 / 命中率 / 复制状态总览 | INFO memory、INFO stats |
CLIENT LIST |
查看客户端连接(阻塞 / 超时定位) | CLIENT LIST |
CONFIG GET maxmemory |
查看 / 修改运行配置 | 调淘汰策略 |
排查思路(面试可背):
- 卡顿 →
INFO stats(instantaneous_ops_per_sec)+SLOWLOG找慢命令; - 内存涨 →
INFO memory(碎片率)+redis-cli --bigkeys找大 key; - 连接满 →
CLIENT LIST+ 业务侧连接池参数; - 命中率低 →
INFO stats(keyspace_hits/misses)→ 看淘汰策略是否过激。
⚠️ 易错点:
MONITOR显著降低吞吐,生产环境谨慎;KEYS *同样禁止——用SCAN游标分批遍历(见第 8 节)。
10.20 Redis 常见反模式与坑(工程师视角)¶
- 把 Redis 当数据库:无持久化 / 单机,重启全丢——缓存必须能容忍丢失(DB 才是事实源);
- 大 value 不设 TTL:过期与淘汰策略形同虚设,内存只涨不降;
- 乱用
KEYS */SMEMBERS/HGETALL(大 key):阻塞主线程,改SCAN系列; SELECT 0-15乱用库:多库不利于集群化(Cluster 不支持多库),用 key 前缀user:1001:info代替;- 热点 key 不做多级缓存:把 QPS 全压 Redis,集群水平扩展被单一槽位击穿;
- 分布式锁不加唯一标识 / 不续期:误删他人锁、锁过期并发执行(见第 6 节);
- 缓存删除失败不重试:一致性靠运气,必须 MQ / binlog 兜底;
- 忽略
maxmemory与淘汰策略配置:内存打满后默认 noeviction 直接写失败。
面试点评:能说出「Redis 是缓存不是数据库」「多级缓存」「删除兜底」这三点, 比背命令更能体现工程素养。
10.21 Redis 面试高频 10 问(快速自测)¶
- 单线程为什么还能撑住高并发? 内存 + epoll 多路复用 + 无锁 + O(1)/O(log N) 数据结构(10.1)。
- ZSet 为什么用跳表不用红黑树? 实现简单、范围查询天然友好、与 dict 配合按 member 找 score。
- 穿透 / 击穿 / 雪崩分别怎么防? 布隆 / 空值兜底;互斥锁 / 逻辑过期;随机 TTL / 多级缓存(第 2 节)。
- 缓存和 DB 一致性怎么保证? Cache-Aside + 删缓存失败重试(MQ / binlog),接受最终一致(第 3 节)。
- RDB 和 AOF 都开了,重启加载哪个? AOF(更接近最新状态);混合持久化则 RDB 快照 + 增量 AOF。
- 8 种淘汰策略怎么背? LRU / LFU / Random / TTL × allkeys / volatile + noeviction(5.2)。
- 分布式锁的坑? SETNX+EXPIRE 不原子 →
SET NX EX;删除要 Lua 校验 UUID;续期用看门狗(第 6 节)。 - Cluster 为什么 16384 槽? 平衡哈希均匀性与 Gossip 位图体积;集群规模千级内足够(7.3)。
- 大 key 和热点 key 怎么处理? 拆 key / UNLINK / SCAN;多级缓存 / 副本打散(第 8 节)。
- 布隆过滤器参数怎么定? m = −n·ln(p)/(ln2)²,k = (m/n)·ln2(2.3)。
点评:1–6 属于必背;7–10 考「方案细节与数字」,回答时带上具体命令 / 公式更稳。
10.22 扩展专题小结¶
| 专题 | 核心一句话 |
|---|---|
| 单线程模型 | 内存 + epoll + 无锁;6.0 IO 多线程不改变命令执行单线程 |
| 命令速查 | 五种结构 + 时间复杂度表格,考前过一遍 |
| 跳表 / 计数布隆 / LFU | ZSet 底层、防穿透、淘汰策略的代码级理解 |
| 一致性 / 缓存策略 | Cache-Aside + 竞态推演 + 版本号,最终一致 |
| 高可用架构 | 单机 → 主从 → Sentinel(高可用)→ Cluster(高可用 + 扩展) |
| 事务 / 管道 / Lua | 「一起发」≠「原子」;复杂原子逻辑用 Lua |
| 限流 | 固定窗口(简单)/ 滑动窗口(平滑)/ 令牌桶(可突发)/ 漏桶(严格) |
| 排行榜 / 延时队列 | ZSet 两大杀手锏应用 |
| HLL | 12KB 内存统计亿级 UV,误差约 0.81% |
| 文件格式 / 内存优化 | RDB 二进制快照、AOF 命令流;编码阈值 512 / 64 / 128 |
| 排查 | --bigkeys / --hotkeys / SLOWLOG / INFO 三板斧 |
至此,第 1–9 节 + 本扩展专题共 40+ 个 cell,覆盖秋招 Redis 高频考点。 祝顺利上岸!本笔记配套仓库:
autumn-recruit-algo/05-八股与工程/。