Redis 全景:从「是什么」到业务深水区
学习对象:想把 Redis 从“听过”学到“能在业务里用”的前端/后端。
章节导览(本表 = 全篇地图,方便按需跳读):
阶段 章 内容 地基 第 1~2 章 是什么 / 怎么连(连接与连接池) 会用 第 3 章 五大基本数据结构(String/Hash/List/Set/ZSet) 原理 第 4~7 章 TTL · 持久化 · 过期vs淘汰 · 慢排查 生产架构 第 8~9 章 主从/哨兵/Cluster · 代理vs直连 当缓存用 第 10~12 章 缓存原理 · 三大故障 · 一致性 业务深水区 第 13~14 章 分布式锁 · 队列/限流/排行/去重 案例 番外 《跨洲缓存》真实复盘 速查 第 15~17 章 命令速查 · 排障链路 · 总结自测 学习方式:按上表从上到下读,每一步都可动手验证(
redis-cli敲一遍)。说明:本篇自包含,覆盖连接与连接池、五大结构、TTL/持久化、过期与淘汰、主从/哨兵/Cluster、缓存三大故障与一致性、分布式锁,以及队列/限流/排行/去重等经典业务模式。
第 1 章 · Redis 是什么?
一句话:Redis 是一个把数据放在内存里的 key-value 数据库——但因为要服务复杂业务,它进化成了“数据结构服务器“。
它快的四个原因(面试必背):
| # | 原因 | 展开 |
|---|---|---|
| 1 | 纯内存操作 | 读写内存 ~100ns,读写磁盘 ~10ms,差 100 倍起 |
| 2 | 单线程(核心命令) | 没有“多线程锁竞争”,也不需要上下文切换——省掉的是“管理成本” |
| 3 | IO 多路复用 | 单线程也能同时监听成千上万个连接(epoll),谁的数据到了就处理谁 |
| 4 | 高效数据结构 | 每种数据类型的存储结构都为访问模式定制过(跳表、压缩列表…) |
为什么“单线程”反而是优点? 前提是命令快。单线程消灭了并发锁,但也意味着:一个慢命令会阻塞所有请求——这是后面排查性能问题的总钥匙(见第 7 章)。
1.1 Redis vs MySQL:不是替代,是分工
| MySQL | Redis | |
|---|---|---|
| 数据在哪 | 磁盘(有缓存) | 内存(持久化兜底) |
| 擅长 | 复杂查询、join、事务、报表 | 高频读写、简单结构、超低延迟 |
| 延迟 | 毫秒~几十毫秒 | 亚毫秒级 |
| 数据完整性 | 强(ACID) | 弱(宕机丢最近数据,看持久化配置) |
分工:MySQL 是“账本”,Redis 是“办公桌上的便签”——热数据、高频计算中间结果放 Redis,事实与余额以 MySQL 为准。
1.2 典型用途(五大件)—— 每一个都有独立章节展开
| 用途 | 用什么结构 | 核心命令 | 详见 |
|---|---|---|---|
| ① 缓存(本专题主线) | String / Hash | SET GET · EXPIRE · DEL | 10~12 章 |
| ② 任务 / 队列(MQ) | List(生产用 Bull 封装) | LPUSH / BRPOP / LRANGE | 3.3 · 14.1 |
| ③ 分布式锁 | String(SET NX EX) | SET NX EX · Lua 原子解锁 | 3.1 · 13 |
| ④ 计数器 / 限流 | String INCR(原子)· ZSet(滑动窗口) | INCR / ZADD / ZREMRANGEBYSCORE | 3.1 · 14.2 |
| ⑤ 排行榜 / 去重 | ZSet(带分数排序)/ Set(去重) | ZADD ZREVRANGE · SADD SINTER | 3.5 · 14.3/14.4 |
读完第三章(五大结构)后再回看这张表,你会发现:“选哪个结构”和“这个用途能不能实现”,是同一件事。
第 2 章 · 怎么连上它(连接与连接池)
redis-cli -h 127.0.0.1 -p 6379 # 命令行客户端
redis-cli PING # PONG = 通了
代码里连(Node.js ioredis):
const Redis = require('ioredis');
const redis = new Redis({ host: '127.0.0.1', port: 6379 }); // 全局唯一实例(连接池内建)
await redis.set('hello', 'world');
await redis.get('hello'); // 'world'
2.1 连接为什么“贵”:一条有状态的专用通道
连接(Connection)= 客户端进程与数据库之间的一条有状态的专用 TCP 通道。和 HTTP 的关键差异:
HTTP 是无状态的——每次请求独立,服务器不“记得”你(认证靠每次带 token)。 数据库连接是有状态的——服务端真的“记得”你在这条连接上设过的 autocommit、隔离级别、临时表。
类比:HTTP 像发一封封邮件(每封独立);数据库连接像拨一次电话(接通后一通到底、服务器一直记得你),挂了要重新拨。
建一条连接要做三件事,每一步都耗时间:
① TCP 三次握手 (网络往返,跨机房更慢)
② 鉴权 / 握手 (校验账号密码权限,可选 TLS 加密)
③ 建会话 (初始化 autocommit / 字符集 / 隔离级别,分配内存缓冲)
2.2 连接池:提前建好、借还复用
高并发下不可能每次请求都新建连接,所以要连接池:提前建好 N 条连接放池里,请求时“借”,用完“还”(而不是关掉)。
客户端 ──借──▶ 连接池 [C1 空闲][C2 已借出✔][C3 空闲] ──分配──▶ 数据库
▲ │
└──────还────────┘ (借完记得还;池满 → 等待 → 超时失败)
- 为什么必须全局共享单例:ioredis 实例自带连接池,全局一个实例 = 全局一个池;每个模块各建实例 = 池失控、连接数暴涨。
- 坑 1 · 连接泄漏:借了不还(忘 close/释放),池被慢慢掏空。
- 坑 2 · 连接被踢:空闲太久的连接会被服务端断开,要校验/重建机制。
- 池满:借不到就等待,等太久超时报错——“连接池耗尽 = 线上事故经典款”。
- 容量公式(Little’s Law):所需连接数 ≈
QPS × RTT / 1000。例:500 QPS × 2ms → 理论 1 条就够,实际设 520 更稳(Redis 单节点 5万10万 QPS,500 QPS 是低负载)。
对数据库(MySQL)连接,这条通道还承载事务边界与会话状态:一条连接上
BEGIN之后的 SQL 才算一批(换连接 = 换事务,跨库没有全局事务的根源);连接断开时未提交的事务会被回滚。深入见 事务篇。
集群/代理/直连的区别见第 9 章;连接相关线上问题(频繁建断/池耗尽)排查见第 7 章“罪 5”。
第 3 章 · 五大基本数据结构(会用)
记忆法:Redis 不是“存字符串的 cache”,是“每种形状的数据都有专门 optimized 容器”。选对结构,命令和不加速都行;选错结构,什么优化都白搭。
3.1 String —— “最通用的键值对”
最容易被低估的结构:看上去就是 get/set,实际上缓存、计数器、锁、限流、签到位图全靠它扛。本节把它说透:命令全景与三种 value 身份 → SET 完整参数 → 四个高频模式 → 与 Hash 的选型 → 坑清单。
3.1.1 命令全景 + 一个 value 的三种身份
| 组 | 命令 | 一句话 |
|---|---|---|
| 读写 | SET / GET / GETDEL(6.2+) / GETEX(6.2+) / APPEND / STRLEN |
GETEX = 读的时候顺便改 TTL |
| 条件写 | SET key val [NX|XX] [GET] [EX|PX|KEEPTTL] |
下小节展开——坑王 |
| 批量 | MSET(原子)/ MGET |
N 次网络往返压成 1 次 |
| 原子计数 | INCR / DECR / INCRBY / DECRBY / INCRBYFLOAT |
整数原地 +1,O(1) 且无竞态 |
| 位操作 | SETBIT / GETBIT / BITCOUNT / BITPOS |
把 String 当位数组用(Bitmap) |
| 简单带 TTL | SETEX key 秒 value |
原子版 SET ... EX;2.6.12 后更推荐参数更全的 SET ... EX |
Redis 按内容把 value 当三种东西存(OBJECT ENCODING key 验证)——这是理解 String 的钥匙:
| value 内容 | 内部编码 | 含义 |
|---|---|---|
纯整数 "12345" |
int | 底层就是 8 字节长整数,INCR 是原地整数加法 |
| 短字符串(≤44 字节,3.2+) | embstr | 对象头与 SDS 一次连续内存分配(省一次 malloc + 内存连续);只读,被改一次就转 raw |
| 长字符串 / JSON / 任何字节 | raw | SDS 简单动态字符串,二进制安全 |
由这张表推出三件事:
- INCR 的原子不靠锁——单线程 + 原地加法,“读出来+1再写回去”的并发覆盖竞态根本不存在(呼应第 17 章自测 1)。
- INCR 只认“看起来是整数的字符串”——计数器 key 一旦被
SET成别的字符串,后续 INCR 直接报WRONGTYPE,整条链路崩。 - SDS 记录长度、结尾不看
\0,所以 JSON、序列化字节随便存——但这不等于该塞大对象(见坑清单第 4 条)。
SET k 1234
OBJECT ENCODING k # "int"
SET k hello
OBJECT ENCODING k # "embstr"
APPEND k world
OBJECT ENCODING k # "raw"——embstr 只读,改过即转 raw
3.1.2 SET 的完整参数:线上一半的“灵异现象”出自这里
SET key value [NX | XX] [GET] [EX 秒 | PX 毫秒 | KEEPTTL]
| 参数 | 语义 | 典型用途 |
|---|---|---|
NX |
不存在才写 | 分布式锁(13 章)、幂等写 |
XX |
存在才写 | 只更新既有缓存,不“顺手新建” |
GET(4.0+) |
设新值同时原子带回旧值 | 替换式更新,替代“GET 再 SET”竞态 |
EX / PX |
写时带 TTL | 带过期的 key 一律用这条命令写 |
KEEPTTL(6.0+) |
保留原 TTL | 只更新 value、不动过期时间 |
⚠️ 头号坑:不带条件的裸
SET key value会顺手清掉该 key 已有的 TTL。 现象各异的“灵异事件”——缓存变永久 key、计数器永不重置、锁永不释放——根源常常是某次更新忘了带 EX。兜底习惯:更新值时显式带EX,或用KEEPTTL。
历史注脚:SETNX + EXPIRE 是两条命令(2.6.12 之前),中间进程崩了就是“永久锁”;SET key val NX EX 30 一条命令后这类坑才根治(锁的完整选型与看门狗见第 13 章)。
3.1.3 四个高频模式(拿着就能抄)
① 缓存 JSON——整存整取
SET user:1 '{"name":"张三","age":18}' EX 300 # 300s 过期
GET user:1
适合“整读整写、无并发改字段”的小对象;需要字段级读写 → Hash(对比表见 3.1.4)。
② 原子计数器——关键是 TTL 归谁管
# 建桶:只有第一笔建得动(NX),且创建即带 TTL
SET rl:api:1001 0 EX 60 NX
# 之后所有请求只自增;INCR 不会清除 TTL
INCR rl:api:1001 # > 100 → 限流(完整方案见 14.2)
反面教材:INCR 后 if (c == 1) EXPIRE key 60 是两步非原子——进程恰好在中间崩,key 永不过期,限流失效。
不用过期的纯计数(如阅读数)直接 INCR article:100:views 就够,多实例并发也不丢。
③ Bitmap——String 的位数组玩法
SETBIT sign:1001:202611 10 1 # 11 月 11 日签到(offset = 日-1)
GETBIT sign:1001:202611 10 # 当天签了吗 → 1
BITCOUNT sign:1001:202611 # 本月签到天数
1 亿用户的“当天活跃”标记约 12MB——布尔打点场景完胜 Set(选型速查见 3.6)。
④ MSET / MGET——批量化
MSET a 1 b 2 c 3 # 原子写入
MGET a b c # 缺失的 key 用 nil 占位
N 个 key 一次网络往返,比循环 GET 少 N-1 次 RTT;注意 Cluster 下多 key 必须同 slot(hash tag,见第 8 章)。
3.1.4 String 存对象 vs Hash:一张表定夺
| 维度 | String(JSON 文本) | Hash |
|---|---|---|
| 读整个对象 | ✅ 反序列化一次最快 | 也可以,字段名还额外占内存 |
| 只改/只取个别字段 | ❌ 整本读改写 | ✅ HGET/HSET 字段级 |
| 字段级原子计数 | ❌ | ✅ HINCRBY |
| 并发更新不同字段 | ❌ 整本互相覆盖 | ✅ 字段间无碍 |
| 大对象风险 | 一整根大字符串 → 大 key(第 7 章) | 分字段天然拆小 |
| 过期 | ✅ SET ... EX |
✅ key 级 EXPIRE(字段级 TTL 要 7.4+ 的 HEXPIRE) |
一句话:单读单写选 String,多字段多写手选 Hash。
3.1.5 坑清单
- 裸 SET 清 TTL(3.1.2 头号坑)→ 永久 key / 锁失效。
- INCR 后没设成 EXPIRE → 永久计数 key:内存涨 + 限流失效。
- 缓存回写竞态:两个客户端拿到同一份旧 JSON,各自改完
SET回去,后写的盖掉先写的 → 用SET key newval GET(4.0+,原子换值并拿回旧值)或 Lua。 - 大 value:String 上限 512MB,但 value 超过 ~10KB 就该按大 key 警惕(第 7 章罪 1);图片/文件本体放对象存储,Redis 只存 URL。
- INCRBYFLOAT 算钱:内部 long double(输出固定 17 位有效数字)有精度陷阱;金额用“分”的整数
INCR。
浓缩版“什么时候用”:缓存 JSON、原子计数/限流打点、分布式锁(SET NX EX)、签到/活跃位图、验证码/一次性 token(SET ... EX + GETDEL 校验即删)、全局 ID 段取号(INCR ... BY n,如今多被雪花 ID 取代)。
3.2 Hash —— “一个 key 下的多个字段”(对象分字段)
HSET user:1 name 张三 age 18
HGET user:1 name # 只拿一个字段 → 不用整对象反序列化
HGETALL user:1
HINCRBY user:1 age 1 # 字段级原子加分
什么时候用:对象的部分读写(如只改昵称)、字段多但每次只取几个。
坑:HGETALL 在大 Hash 上是 O(N),会阻塞——用 HSCAN 分页。
3.3 List —— “有序、可阻塞的列表”(队列的天职)
LPUSH task:queue '{"id":1}' # 左进
RPOP task:queue # 右出(先进先出)
BRPOP task:queue 30 # 阻塞版:没任务等 30s(消费工作者的标配)
LRANGE task:queue 0 9 # 看前 10 条(大列表要分页)
LLEN task:queue # 队列长度
什么时候用:任务队列(Bull 的底层)、最新消息列表(前 N 条)、待办池。 坑:不要用它做“任意位置的删除”(O(N));不要 BRPOP 在多个进程间乱用造成“任务丢失”(要 ack 机制 → 用 Bull/SRPStream 等成熟方案)。
3.4 Set —— “无序、去重的集合”
SADD fans:user:1 u2 u3 u4
SINTER fans:user:1 fans:user:2 # 共同关注(交集)
SISMEMBER fans:user:1 u2 # 是否是关注者
SCARD fans:user:1 # 总数
SPOP lottery:pool # 抽奖:随机弹出
什么时候用:去重(同一用户不能重复报名)、关系判断(是否点赞过)、共同好友/标签交并差(SINTER/SUNION/SDIFF)。
3.5 ZSet —— “带分数的排序集合”(排行榜/延时队列)
ZADD rank:day 9800 user:1 # score = 分数
ZINCRBY rank:day 5 user:1
ZREVRANGE rank:day 0 9 WITHSCORES # Top10
ZRANK rank:day user:1 # 我的排名
ZADD delay:task 1690000000 job:1 # score = 执行时间戳 → 延时队列
什么时候用:排行榜(热搜榜、积分榜)、延时队列(score 存“该执行的时间”,定时轮询 ZRANGEBYSCORE)、限流滑动窗口。
3.6 三分钟选型速查
| 需求 | 用什么 |
|---|---|
| 缓存一个 JSON | String |
| 对象部分读写 | Hash |
| 任务队列 / 最新 N 条 | List |
| 去重 / 布尔关系 / 抽奖 | Set |
| 排行榜 / 延时队列 | ZSet |
| 计数器 / 分布式锁 | String (INCR / SET NX) |
| 用户月签到 | Bitmap |
| 布尔统计(百万级去重计数) | HyperLogLog |
| 附近的人 | Geo |
第 4 章 · TTL 与 Key 管理
EXPIRE key 300/SET ... EX 300:给 key 设活着的时间。- 过期了,Redis 不实时删,而是两种机制配合(详见第 6 章表格):
- 惰性删除:访问时判过期才删。
- 定期删除:每秒 10 次、随机抽 20 个过期 key 来删。
- 遍历全集别用
KEYS *(会阻塞所有请求),用SCAN 0 MATCH user:* COUNT 100游标式增量。
Key 命名规范(团队约定):业务:对象:id:字段,如 order:detail:1001:base。好处:可读 + 便于按前缀批量清理/统计。
第 5 章 · 持久化:把内存数据落到磁盘
Redis 数据全在内存里——进程一挂,内存清零。持久化就是“断电后还能起死回生”的唯一手段。三种方式一张表总览,细节在 5.1~5.5:
| 方式 | 原理 | 优点 | 代价 |
|---|---|---|---|
| RDB | 定时把内存快照写成文件(BGSAVE fork 子进程) | 文件小、恢复快 | 两次快照之间宕机会丢数据;fork 有卡顿(7 章罪 3) |
| AOF | 每条写命令都追加到日志(append) | 最多丢 1 秒(everysec) | 文件更大、恢复慢 |
| 混合持久化(4.0+) | RDB 全量 + 增量 AOF | 两者兼得 | 略复杂 |
5.1 RDB:定时快照(Snapshot)
原理:把某个瞬间整个内存的键值状态,以紧凑的二进制格式 dump 成一个 dump.rdb 文件。恢复时整个文件载入内存即可——所以恢复快。
怎么触发快照? 三条路:
# ① 自动:配置文件按"变化频次"定时触发(默认策略)
save 900 1 # 900 秒内至少 1 个 key 变化
save 300 10 # 300 秒内至少 10 个 key 变化
save 60 10000 # 60 秒内至少 10000 个 key 变化
# ② 手动:BGSAVE 后台 fork 子进程做(不阻塞服务,推荐)
redis-cli BGSAVE
# ③ 兜底:SHUTDOWN 正常关闭时落一次盘;主从全量同步时主库也会生成 RDB
关键是 fork + 写时复制(COW)——RDB 快也不快,都在这一步:
BGSAVE → fork() 出子进程 → 父子共享同一份物理内存页
→ 子进程按页遍历写入 dump.rdb
→ 期间父进程照常服务!
父进程改某页数据 → 才把那一页复制一份给父进程(写时复制)
两个推论:
- fork 本身会卡主进程:复制的是页表(不是数据),越大的实例页表越大,卡顿越久(经验值:GB 级实例几十毫秒起步,越大越糟)——这就是第 7 章“罪 3 持久化阻塞”的根源。
- 极端时内存可能接近翻倍:快照期间写入越猛,COW 复制的页越多。内存规划要给持久化预留 30%~50% 余量(
maxmemory不含这部分)。
启动日志里若见
Transparent Huge Pages (THP) enabled警告,建议关掉 THP——大页会让 COW 的复制粒度变成 2MB,加剧内存与延迟问题。
动手验证 30 秒:
redis-cli BGSAVE # 后台保存
ls -la dump.rdb # 看文件
redis-check-rdb dump.rdb # 校验文件完整性
5.2 AOF:写命令日志(Append Only File)
RDB 是“结果快照”,AOF 换个思路——把每条写命令按顺序记下来,恢复时从头重放一遍,状态就回来了。
# 开启:appendonly yes
SET name zhangsan
# AOF 里记录的就是一条可读的协议命令(Redis 6 及之前):
# *3\r\n$3\r\nSET\r\n$4\r\nname\r\n$8\r\nzhangsan\r\n
核心参数只有一个:appendfsync——“多快把命令真正刷到磁盘”:
| 策略 | 行为 | 丢失窗口 | 适用 |
|---|---|---|---|
always |
每条命令都 fsync | 基本不丢 | 极慢,几乎不用 |
everysec(默认⭐) |
后台线程每秒 fsync 一次 | 最多丢 1 秒 | 绝大多数场景 |
no |
交给 OS 决定何时刷 | 不确定(可能几秒) | 快但不安全 |
进阶一点:
everysec下若磁盘太烂、后台 fsync 超过 2 秒还没完成,主线程写 AOF 时会强制等待落盘——所以“everysec 不阻塞”的前提是磁盘别太烂。
AOF 会越来越肥 → 重写(rewrite):第 100 次 INCR counter 在日志里有 100 条,但当前状态只是一条 SET counter 100。AOF 重写就是按内存现状生成最小命令集,把历史脏账压平:
redis-cli BGREWRITEAOF # 手动触发;日常靠自动策略:
auto-aof-rewrite-percentage 100 # 文件比上次重写后大 100% 时触发
auto-aof-rewrite-min-size 64mb # 且至少 64mb 才值得
重写同样走 fork(同样的卡顿与 COW 内存问题);重写期间的新写命令由缓冲区记录、结束后补写进新文件——不丢。
动手验证:
redis-cli CONFIG SET appendonly yes
redis-cli SET foo bar
cat appendonly.aof # 能看到你刚敲的命令(6.x);7.x 在 appendonlydir/ 下的 incr 文件
Redis 7 的 AOF 拆成 Multi-Part:
appendonlydir/下base(基础)+incr(增量)+manifest(清单)三个文件协同——概念不变,落地形式变了。
5.3 混合持久化(4.0+,默认开):RDB 头 + AOF 尾
RDB 恢复快但丢得多,AOF 丢得少但重放慢——混合持久化把两者拼进同一个文件(aof-use-rdb-preamble yes,5.0 起默认开):
- AOF 重写时,先以 RDB 二进制格式把当前全量状态写进文件头,之后的增量命令照旧 AOF 文本追加;
- 恢复时:快读 RDB 头 + 只重放尾部少量命令——恢复速度接近 RDB,数据量接近 AOF。
5.4 怎么选(决策表) + 都开了哪个先生效?
| 场景 | 推荐 | 理由 |
|---|---|---|
| 纯缓存(丢了能从 DB 重建) | RDB 或干脆 appendonly no + save "" |
追求极致性能,宕机回源 DB |
| 任务队列 / 锁(如 Bull) | AOF + everysec(建议再配 RDB) | 丢 1 条锁/任务 = 事故,丢 1 秒可容忍 |
| 数据重要(单用 Redis 当库) | 混合持久化 + 从库 + 哨兵 | 单机持久化不够,高可用兜底(第 8 章) |
若 RDB/AOF 都开,重启恢复时 AOF 优先(它更完整);AOF 损坏可用
redis-check-aof --fix修复。
运维别漏一步——异地备份:持久化文件和 Redis 在同一台机器,磁盘毁了它也跟着一起死。定时把 RDB/AOF 拷到远端(crontab + scp / 对象存储),才是完整的“落盘”方案。
5.5 持久化常见坑
- fork 是三大卡顿之一:BGSAVE、AOF 重写、主从全量同步都会 fork——别同时踩两个(如把
BGSAVE和BGREWRITEAOF定时都设在业务高峰)。 - 内存余量没留够:COW 期间内存飙升 → 触发 maxmemory 淘汰、甚至 OOM。容量按“预计数据 + 30%~50%“规划。
- 以为 everysec= 不丢数据:它是“最多丢 1 秒”,且磁盘慢时可能阻塞主线程;真的不能丢就
always+ SSD + 从库。 - AOF 只增不减:忘了 auto rewrite(被人为改小/关闭)→ 文件无限膨胀,恢复时间越来越长。
缓存场景的取舍(重申):纯缓存可关 AOF 只留 RDB 甚至不持久化,追求极致性能;存“任务队列/锁”必须 AOF + everysec。
第 6 章 · 过期删除 vs 内存淘汰(两件不同的事,别搞混)
| 过期删除(Expiration) | 内存淘汰(Eviction) | |
|---|---|---|
| 触发 | key 设置了 TTL 且时间到 | 内存满了(达到 maxmemory) |
| 机制 | 惰性删除(访问才判)+ 定期删除(每秒 10 次抽 20 个,超 25% 再来一轮) | 按 maxmemory-policy 清理 |
| 策略 | 只有上面一种(默认同时开) | 8 种策略 |
推论(理解击穿/雪崩的钥匙,见第 11 章):key 过期 ≠ 立刻消失——“逻辑已过期、物理删除滞后”的瞬间正是击穿/雪崩的窗口。 关注过期的两条产出:定期删除是随机抽查、代价极小,“Redis 频繁过期拖垮读取”多半是误判,先算自己的 TTL 与访问频率。
8 种内存淘汰策略(maxmemory-policy,常用的 5 种):
| 策略 | 含义 |
|---|---|
| noeviction(默认) | 内存满就报错,不删 |
| allkeys-lru | 所有 key 里挑“最久未使用”的删(缓存首选) |
| volatile-lru | 只在设了过期时间的 key 里挑 LRU 删 |
| allkeys-lfu / volatile-lfu | 同上,按访问频率删(4.0+) |
| allkeys-random / volatile-random | 随机删 |
缓存场景选哪种? 纯缓存首选
allkeys-lru;key 有明显冷热差异(有的被反复读、有的偶尔读)用allkeys-lfu更贴切;只允许清理“反正会过期”的 key 时用volatile-*系列。
第 7 章 · Redis 慢?排障清单(排查链路 + 六宗罪)
单线程是总钥匙:一个大 key 或慢命令 = 阻塞所有请求。下面先是排查链路,再逐个拆“六宗罪”。
7.1 先建一条“排查链路”(不要瞎猜)
Redis 变慢,先动手把“慢”拆成三类——到底是【网络慢】【Redis 执行慢】还是【客户端处理慢】:
1. redis-cli --latency -h host # ① 网络往返 RTT
2. redis-cli SLOWLOG GET 10 # ② 服务端慢命令
3. redis-cli INFO cpu # ③ 服务端 CPU 负载
4. redis-cli INFO memory # ④ 内存/淘汰压力
5. redis-cli INFO persistence # ⑤ 是否正在 RDB/AOF 落盘
6. redis-cli CLIENT LIST | wc -l # ⑥ 连接数是否异常
7. redis-cli --bigkeys # ⑦ 有没有大 key
客户端打点也很关键:把“网络时间 / Redis 执行时间 / 反序列化时间”分开计——经常是
JSON.parse花了 50ms,被误认为“Redis 慢”。
7.2 六宗罪(每个:现象 / 排查 / 解法)
罪 1 · 大 Key
- 现象:单条读特别慢,但网络正常。
- 典型:一个 Hash 十万字段、一个 String 超 10MB、一个 List 百万条。
- 排查:
redis-cli --bigkeys。 - 解法:拆分(
user:1:profile/user:1:settings)、用 Hash 分字段按需读、大 value 压缩(gzip)。
罪 2 · 慢命令(单线程阻塞放大器)
- 现象:某次读突然很慢,之后一波请求都慢。
- 本质:Redis 单线程执行命令——一个慢命令阻塞后面所有请求。
| 命令 | 复杂度 | 风险 |
|---|---|---|
KEYS * |
O(N) | ❌ 线上严禁 |
HGETALL big_hash |
O(N) | 返回太多 |
LRANGE big_list 0 -1 |
O(N) | 全量拉取 |
SMEMBERS big_set |
O(N) | 同上 |
- 解法:
SCAN替代KEYS;集合分页(ZRANGEBYSCORE + LIMIT);slowlog-log-slower-than监控慢查询。
罪 3 · 持久化阻塞
- 现象:某次读取“突然”耗时上跳(赶巧赶上落盘)。
- 原因:
BGSAVE虽是子进程,但 fork 主进程会卡顿(内存越大越明显);AOF rewrite 同理要大量写盘。 - 排查:
INFO persistence。 - 解法:避开高峰触发 RDB/AOF;用 SSD;单实例内存别太大(建议 <10GB)。
罪 4 · 网络延迟 / 带宽
- 现象:执行很快,但端到端耗时长。
- 原因:客户端与 Redis 不同机房、走公网、带宽被批量导出打满。
- 排查:
redis-cli --latency、iftop。 - 解法:同机房/同可用区部署、内网访问——跨洲跨区是毫秒级 vs 同机房亚毫秒级的差距(真实案例里这一步把 200ms 干到 2ms)。
罪 5 · 连接 / 连接池配置不当
- 现象:延迟高且抖动大;每次调用都“比别人多一截”。
- 原因:每次请求新建连接(TCP 握手 0.5~3ms + TLS 更久)、无连接池、TIME_WAIT 堆积。
- 排查:
CLIENT LIST,看连接是否频繁重建。 - 解法:连接池全局共享(ioredis
lazyConnect、maxConnections10~30);合理 timeout;细节见第 2 章。
罪 6 · 客户端序列化 / 反序列化
- 现象:Redis 执行只花 2ms,但总耗时 50ms。
- 原因:大 JSON 的
JSON.parse慢;或取回了不必要的大字段。 - 解法:客户端分段打点定位;改 MessagePack / Protobuf;用 Hash 分字段按需读(
HGET user:1 name),别全量拉。
7.3 归因方法论:优化有效之后,怎么复盘“当时为什么慢”
优化有效 ≠ 能反推出唯一原因。用排除法:
| 证据 | 指向“自身链路问题” | 指向“外部竞争” |
|---|---|---|
| 网络延迟高 | ✅ | ❌ |
| 连接频繁建断 | ✅ | ❌ |
| Redis CPU 高 | ❌ | ✅ |
| SLOWLOG 有慢命令 | ❌ | ✅ |
| 其他服务也慢 | ❌ | ✅ |
真实案例结论:连接池消除了建连开销(3000→200ms),同区域部署消除了跨洲延迟(200→2ms)——是自己“走了一条低效的路”,而非“被别人抢资源”。要“假设竞争成立”,必须有 INFO cpu 高、SLOWLOG 多这些证据。
换 Redis 独立实例/分片可以隔离“别人抢资源”,那是容量规划;而先优化自己是性价比最高的一步。
第 8 章 · 部署形态演进(每种形态解决什么问题)
① 单机 ────────► 读多→撑不住、挂了没备份
② 主从复制 ────────► 主写从读、读写分离(见 8.1~8.3)
③ 哨兵 Sentinel ────► 主库挂了自动"选新主"(高可用,见 8.4)
④ Cluster 集群 ─────► 数据按 slot(16384)分片 → 容量横向扩展
8.1 为什么要主从/副本:单库的两个痛点
| 痛点 | 副本(主从)解决 |
|---|---|
| 读太多,单库扛不住 | 主库写,多个从库读 → 读水平扩容 |
| 主库挂了没备份 | 从库随时能顶上来 → 高可用 |
┌─▶ 从库 A(读)
主库(写) ──┤
└─▶ 从库 B(读)
主库把每一次写"同步"给从库 = 复制
与分库分表互补:分库分表是“横向拆数据”,主从是“纵向加副本”——一个拆数据、一个扩读与备份,常一起用。
8.2 复制原理:binlog(一句话说清)
主库把每次写进 binlog(二进制日志),从库拉取 binlog 在本地重放:
主库写 → 写 binlog → 从库 IO 线程拉 binlog → 从库 SQL 线程重放 → 从库也变了
Redis 的主从同理(用的是 PSYNC/replication feed 而非 binlog 名词)。复制是异步的——这正是下一节“主从延迟”的根源。
8.3 主从延迟(最大的坑)与读写分离
从库数据比主库旧一点点 → 刚写完就读,可能读不到。
解决:
- 读写分离时,敏感“写后读”走主库(如:下单后马上查订单 → 强制走主库);
- 延迟可接受场景(列表页/报表)才走从库;
- 一主一从变半同步复制,可降低延迟窗口。
代码层(中间件自动路由,或自己指定数据源):
@ReadDataSource // 伪注解:查询 → 从库
public Order getOrder(Long id) { ... }
@WriteDataSource // 写 → 主库
public void update(Order o) { ... }
关键心智:主写从读 + 接受轻微延迟;对一致性敏感的操作强制走主。注意主从不解决写压力——写仍只在主库。
8.4 高可用:主挂了怎么办
主备切换(Failover):主库挂了 → 哨兵/高可用中间件检测 → 把一个从库提升为主(或从备份恢复)→ 应用连到新主。
-
Redis 哨兵(Sentinel):监控主库、投票选新主、通知客户端换地址(Redis 自带的高可用)。
-
MySQL:MHA / MGR / 从库 promote + 改连接。
-
切换窗口期,写请求可能短暂不可用(可用性上的一点点牺牲)。
-
哨兵(Sentinel):监控主库、投票选新主、通知客户端换地址(Redis 自带的高可用)。
8.5 Cluster 集群
- Cluster 集群:把 16384 个 hash slot 分给多台主库,
key按 CRC16 路由——容量与写入量都能横向扩,但要接受“多 key 操作/事务受限”(只能操作同一个 slot 的 key,用 hash tag{user1}:a解决)。
⚠️ 事务/锁/队列(如 Bull)在 Cluster 下有额外约束:多 key 必须同 slot(key 里加
{hashTag});客户端要支持 Cluster(ioredisRedis.Cluster),不能当单机连。
第 9 章 · 代理 vs 直连(云 Redis 的典型抉择)
| 代理模式(Proxy) | 直连模式(Direct) | |
|---|---|---|
| 拓扑/路由 | 代理自动处理(MOVED/ASK 无感) | 客户端自己维护(slots 管理) |
| 连接管理 | 代理内置连接池 | 客户端自己配 |
| 网络路径 | 客户端→代理→节点 | 客户端→节点(更短) |
| 稳定性 | 稳定低抖动 | 处理不好反而慢 |
直连变慢的四个场景:
- 客户端没正确处理 MOVED/ASK 重定向(等待超时、反复打到错误节点)。
- slots 频繁刷新(
slotsRefreshTimeout大 → 首屏有人卡 10s)。 - Bull 不是天生 Cluster 感知——传单机配置会全部写到一个节点(热点+重定向慢):
// ✅ Bull 要传 ioredis Cluster 实例,不是 { host, port } const queue = new Queue('email', { connection: redisCluster }); - 无连接池 → 每任务新建连接(TCP+认证+slot 初始化)。
代理 6ms 的秘密不是网络快,而是“智能网关替你承担了全部复杂性”——直连后“自己变慢”,要做的不是退回代理,而是把缺失的连接池/重试/同区域部署补回来(真做完可超过代理性能,见番外《跨洲缓存》3000→200→2ms)。
排障小贴士:直连模式调低
commandTimeout却还是卡 30s?常见原因是maxRetriesPerRequest: null无限重试 × 超时叠加——要配合总超时/熔断。
缓存是 Redis 最常见、也最容易被用错的场景。第 10~12 章把缓存从原理到工程讲透:为什么快、缓存放哪、三大故障怎么防(带代码)、缓存与库怎么保持一致,最后给一个把全部手段串起来的完整实现。
第 10 章 · 为什么需要缓存 + 缓存模型与三级层级
10.1 为什么要缓存:不是“优化”,是硬件规律
一句话:存储的速度差几个数量级,把热数据放更快的地方,是用一次性成本换长期读速。
CPU 缓存(~ns) → 内存(~100ns) → SSD(~0.1ms) → 磁盘(~10ms) → 网络/DB(~几十ms+)
前端直觉:对昂贵计算结果做
memoize、对静态资源做 HTTP 缓存,是同一件事;后端只是把“贵的读 DB”缓存到“便宜的 Redis/内存”。
关键前提:局部性——热点数据只有一小撮,却占绝大多数访问(二八定律)。缓存只对“有局部性”的数据有效。
10.2 基本模型与两个指标
客户端
│ ① 查缓存
▼
Redis ──命中(hit)──▶ 直接返回 (快)
│ ② 未命中(miss)
▼
DB 查询 → ③ 回填缓存 → 返回
- 命中率 = 命中次数 / 总查询,越高越好(目标是 >90%)。
- 穿透率 = 未命中里“查 DB 也没有”的比例(见 11.1 穿透)。
10.3 缓存放哪:三个层级(和各自的坑)
| 层级 | 载体 | 特点 | 典型坑 |
|---|---|---|---|
| 本地缓存 | 进程内 Caffeine/LRU Map |
最快、零网络 | 多实例各自一份 不一致;内存占用 |
| 分布式缓存 | Redis | 多实例共享、主流 | 网络一次;Redis 挂=全没(要高可用) |
| 浏览器/CDN | 用户侧、边缘 | 静态资源、最靠前端 | 缓存过期/强缓存策略 |
生产典型:本地(L1) → Redis(L2) → DB,逐级兜底。但 L1/L2 一致性要额外管(本地易脏)。
10.4 三种读写模式(别只会 Cache-Aside)
| 模式 | 读 | 写 | 适用 |
|---|---|---|---|
| Cache-Aside(旁路) ⭐ | 先查缓存→未命中查库回填 | 先删/写缓存,再写库(顺序有讲究,见 12.2) | 90% 的业务 |
| Read/Write-Through | 应用只和缓存对话,缓存自己同步 DB | 同步写穿 | 有成熟缓存层时 |
| Write-Behind(异步落库) | 先写缓存,异步批量刷库 | 写极快,有丢失风险 | 计数、点击量、点赞 |
🎯 面试常问:为什么大家用 Cache-Aside? ——实现简单、责任清晰(缓存只是副本,DB 才是真相源);配合“写库后删缓存“策略,一致性问题收敛到”读时重建“。
读时重建是什么意思? 写方只负责删缓存、从不负责把新值算进缓存;Cache-Aside 删了之后缓存是“空”的,等下一个读请求 miss 时,它自己再去 DB 查即时的真值回填——新值是读请求按 DB 现值现场重建的,所以天然和 DB 一致,写方压根不需要“把缓存算对”。而 DEL 是幂等操作,删错顶多多一次 cache miss,风险远小于“写时更新缓存”可能造成的缓存与 DB 不一致。
第 11 章 · 三大故障:穿透 / 击穿 / 雪崩(原理 + 代码)
一表区分(必背):
| 打的是谁 | 本质 | |
|---|---|---|
| 穿透 | DB(key 根本不存在) | 查询了不存在的数据 |
| 击穿 | DB(单个热点 key) | 热点 key 过期瞬间 |
| 雪崩 | DB(大批) | 一堆 key 齐过期 / Redis 宕 |
钥匙在前文:过期删除是“惰性 + 定期”双机制(第 6 章),key 过期 ≠ 物理立刻消失——击穿/雪崩的窗口正是“逻辑已过期、物理处理滞后”的瞬间。
11.1 缓存穿透 —— 查“根本不存在”的 key,每次都打 DB
现象:一个 key 缓存和 DB 都没有(如恶意造 userId=-1、id=99999999)。每次查都 miss → 落到 DB。攻击者用不存在 id 循环请求 → DB 被白打。
请求 -id不存在- → 缓存 miss → DB miss → 下个请求又 miss → 又打 DB(穿透了隔离)
解法 1:缓存空结果(简单、最常用)
// 查询不存在时,把"null"也塞进缓存,短过期
Order o = redis.get(key);
if (o == null) {
o = dao.findById(id);
if (o == null) {
redis.setex(key, 60, "NULL"); // 缓存空,60s 过期;并返回"无"
} else {
redis.setex(key, 300, o);
}
}
注意:空值别存太短(否则又穿透),也别太长(真来了数据也不准)。
解法 2:布隆过滤器(拦截在缓存前) 在缓存前加一个位图,判断“这个 key 可能存在吗”——说“不存在”必准确,说“存在”可能误报:
对每个真实 key 做多次 hash,把位图对应位置 1
查询:若所有位都是 0 → 一定不存在 → 直接拒绝,不打 Redis/DB
若至少一位是1 → 可能在 → 放行去查(有少量误报)
BloomFilter<Long> bloom = BloomFilter.create(Funnels.longFunnel(), 1_000_000, 0.01);
// 预热:把所有存在的 id 加进去;查询前先用 bloom.mightContain(id) 挡
布隆特点:省内存(位图)+ 不可删除元素;会误报但不漏报。
11.2 缓存击穿 —— 单个“热点 key”过期瞬间,请求全打 DB
现象:某个极热的 key(秒杀库存、热点商品)刚过期。正常命中时 1w 请求里只有少数 miss 打 DB;过期的一瞬间,本来该命中缓存的上万请求一起 miss、同时扑向同一行热点数据 → DB 瞬间被打爆。
解法 1:互斥锁(重建只放一个) 给“查 DB + 回填缓存”这件事加分布式锁:只放抢到锁的第 1 个请求去查 DB,其余请求短暂自旋等待,等它回填后命中缓存直接返回——DB 只被真正查一次(锁的细节见第 13 章):
public String getHot(String key) {
Object v = redis.get(key);
if (v != null) return v;
// 抢锁:只让一个线程去重建,其余等待
if (redis.setnx("lock:" + key, "1", 5_000)) {
try {
v = dao.query(key); // 重建
redis.setex(key, 300, v); // 回填
} finally {
redis.del("lock:" + key);
}
return v;
} else {
Thread.sleep(50);
return getHot(key); // 没抢到锁,重试等别人建好
}
}
代价:击穿瞬间短暂阻塞(其余请求等锁)。适合“必须有最新值”的热点。
解法 2:逻辑过期(不真删,异步刷新) key 不设真 TTL(value 物理上永不消失、永不 miss),而是把“逻辑过期时间”存进 value;读时发现逻辑过期 → 先返回旧值顶住(不 miss、不阻塞),同时后台异步/加锁查 DB 重建:
value = { data: ..., logicalExpire: 1234567890 }
读:数据没过期 → 直接返回
数据逻辑过期 → 先返回旧值,再异步/加锁重建新值
优点:读不阻塞(不击穿 DB,同时还能响应旧值);缺点:短暂旧数据。适合“秒杀前库存”这种可容忍旧一点点、但要扛高峰的场景。
11.3 缓存雪崩 —— 一大批 key 同时过期 OR Redis 整体挂了
现象:大量 key 同一时刻过期 → 一大波请求齐打 DB;或 Redis 集群整体不可用 → 流量全压 DB。
解法:
- 过期时间加随机抖动:
expire = base + random(0..1000),避免整批同时过期。 - 多级缓存:Redis 挂/未命中时,还有一份**本地缓存(L1)**扛读。
- 限流熔断:DB 扛不住时先限流/熔断,保常规服务,别让 DB 被打死。
- Redis 高可用:哨兵/集群(见第 8 章),别让“缓存宕”成为常态。
第 12 章 · 缓存一致性:写库后怎么让缓存“不脏”(完整版)
问题:库里已更新,缓存还是旧的(读到脏数据)。
12.1 为什么“先更新缓存”不行
方案A:先写库,再写缓存
若写缓存那步失败 → 库新、缓存旧 → 一直脏
若写库成功、缓存更新前读到了旧缓存 → 也不一致
12.2 Cache-Aside(旁路缓存,最常用)
读:先查缓存 → 命中返回 / 未命中查库并回填
写:先删缓存(旧值作废) → 再写库 → 下次读重建
为什么“先删缓存、再写库”,而不是“先写库、再删缓存”?
- 先删缓存 → 写库即使失败,缓存也是空的(下次读重建正确的),最多多打一次库,不会脏。
- 后写库再删缓存:若删缓存失败,就永远旧。
“先删缓存 + 并发写”的隐患(经典时序):
A: 删缓存 →(准备写库)
B: 读缓存 miss → 查库(旧) → 回填旧缓存
A: 写库(新) ← 结果:缓存是 B 回填的旧值
解法:延迟双删——A 写库后再延迟几百 ms 删一次缓存,把 B 回填的旧值清掉:
public void update(Order o) {
redis.del(key); // ① 删缓存(旧值作废)
dao.update(o); // ② 写库
Thread.sleep(300); // ③ 让并发中"回填旧缓存"的请求完成
redis.del(key); // ④ 延迟双删:清掉可能被回填的旧值
}
延迟双删不完美(仍有短暂窗口),但对大多数业务足够。
12.3 什么时候最不需要纠结一致性?——“缓存只做读快照”
很多场景缓存本来就是“允许旧的”:排行榜、商品描述、计数。这类只要过期重建即可,不必双删——别把一致性复杂化用到不需要的地方。
12.4 一致性再进阶:binlog 订阅与对账兜底
- 进阶:订阅 binlog(如 canal)触发删缓存——把“删缓存”的可靠性交给专门的组件;复杂度上不去时别硬上 binlog 订阅。
- 兜底:无论哪种方案都有短窗口不一致 → 用对账任务最终收敛。
12.5 综合实现:商品详情 + 库存(防穿透 + 防击穿 + 防雪崩一起上)
@Service
public class SkuService {
// 读:Cache-Aside + 防穿透(空值) + 防击穿(互斥锁) + 防雪崩(随机过期)
public Sku getSku(Long id) {
String key = "sku:" + id;
Object v = redis.get(key);
if (v != null) return v == NULL_SENTINEL ? null : (Sku) v;
if (redis.setnx("lock:" + key, "1", 3000)) {
try {
v = skuDao.findById(id);
int ttl = 300 + (int)(Math.random() * 60); // 防雪崩:随机抖动
if (v == null) { redis.setex(key, 60, NULL_SENTINEL); return null; } // 防穿透
redis.setex(key, ttl, v);
return (Sku) v;
} finally { redis.del("lock:" + key); } // 防击穿:互斥重建
}
sleepRetry(); return getSku(id);
}
// 扣库存:Redis 原子 DECR + 不够就回拨
public boolean decrStock(Long id, int n) {
Long left = redis.decrBy("stock:" + id, n); // 原子
if (left < 0) { redis.incrBy("stock:" + id, n); return false; } // 回拨
return true;
}
}
12.6 缓存常见坑 & 面试追问
- 别为了防击穿给所有 key 都加互斥锁——只给热点 key;否则把高并发变成串行。
- 空值缓存别存太长——否则“数据来了但读不到”。
- 布隆过滤器不能删元素——下线/删除数据后它仍误报“存在”。
- 本地缓存与 Redis 并存时记得一致性——L1 脏的坑!
🎯 面试常问:
- 穿透/击穿/雪崩怎么区分?——见第 11 章开篇一表。
- 先删缓存再写库,为何还可能不一致?并发下谁回填旧值?——见 12.2 时序;用延迟双删。
- 防击穿的互斥锁,该给谁加?——只给热点 key;锁用
SETNX(呼应第 13 章)。 - 缓存和 DB 最终不一致不管了吗?——短窗口可接受 + 对账任务兜底。
第 13 章 · 分布式锁:SETNX 就够,但细节要命(完整版)
13.1 为什么需要分布式锁(和单机锁的区别)
单机:synchronized / ReentrantLock —— 进程内互斥
多实例:多个进程同时抢同一个任务/改同一资源 → 进程内锁管不住
→ 需要一个"大家都看得见、能抢"的锁 → Redis / ZK / 数据库
什么时候需要:当一个业务(定时任务、库存扣减)部署多个实例时,就要“跨实例互斥”——多实例防重复执行的底层就是它。
13.2 从最朴素的 SETNX 到它的三个坑
基本姿势:
# 加锁:不存在才设置 + 30s 过期
SET lock:order:1 <requestId> NX EX 30
# 干活...
DEL lock:order:1 # 释放
一个坑接着一个坑:
| 问题 | 说明 | 关键解法 |
|---|---|---|
| 锁被别的线程删了 | A 锁过期,B 抢到,A 又 DEL 把 B 的锁删了 |
释放时校验 value(owner/线程id),是自己的才删 |
| 持锁时间不够 | 任务没跑完锁就过期,别人进来 | 锁续期(看门狗),见 13.3 |
| 判断+删除非原子 | 先 GET 校验再 DEL → 中间过期/被抢 | 用 Lua 脚本保证“校验+删除”原子 |
释放锁必须原子(Lua)——只能删自己的锁:
-- 只有 value 等于自己的才删 —— 防"删到别人锁"
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
else
return 0
end
呼应 3.1.2 的历史注脚:
SETNX+EXPIRE两条命令的时代(2.6.12 之前),加锁本身都可能半途而废留下“永久锁”;SET key val NX EX 30一条命令后才根治。
13.3 看门狗(Watchdog):锁要自动续期
问题:锁设 30s,任务要跑 60s → 后半段锁已没了,别人也能进来。
解法:看门狗——持有锁期间,后台每约 1/3 过期时间自动续期;任务完成才取消续期(释放)。
类比:占座;怕超时,就每隔一会儿举手刷新一下“我还在”。这就是 Redisson 的看门狗机制(默认 30s、每 10s 续一次)。
13.4 Redis 单点挂了怎么办:RedLock 与方案选型
痛点:锁存在一台 Redis,它挂了 → 锁没了。
| 方案 | 原理 | 是否推荐 |
|---|---|---|
| Redis 单机 + 看门狗 | 简单够用(配哨兵/集群高可用,见第 8 章) | ✅ 绝大多数场景 |
| RedLock | 锁写在多个独立 Redis,多数成功才算拿到 | ⚠️ 有争议(脑裂/时钟漂移),复杂度高,多数团队不需要 |
| ZooKeeper 临时节点 | 会话断开自动释放、顺序节点公平 | ✅ 追求强一致/公平时 |
| 数据库乐观锁/唯一索引 | 用 DB 做锁 | 低频可 |
🎯 面试常问:RedLock 一定更安全吗?——不一定。它引入多机 + 时钟/网络复杂度,且有“锁被平分/脑裂”的争议;实际很多系统用“单机 Redis + 看门狗 + 哨兵高可用”就够。选型看一致性要求与团队复杂度接受度。
13.5 怎么用(Redisson 伪码)——锁不是底线,幂等才是
RLock lock = redissonClient.getLock("lock:order:" + orderId);
try {
// 默认看门狗 30s,每 30/3 秒自动续期
lock.lock(30, TimeUnit.SECONDS);
// ... 只有拿到锁的实例能进来 ...
} finally {
if (lock.isHeldByCurrentThread()) lock.unlock();
}
真正的关键:拿到锁后的「业务」还要幂等——锁是优化、幂等是底线(锁可能过期/失效,幂等兜底)。
第 14 章 · 其他“经典变体”:任务队列 / 计数器限流 / 排行榜去重
14.1 任务队列(用 Redis List 实现,生产换 Bull)
为什么用 Redis 做队列? 对比一下 MQ 选型:
| 中间件 | 复杂度 | 适合场景 | 部署 |
|---|---|---|---|
| Redis List | 低 | 轻量级任务队列、快速上手 | 单进程,开箱即用 |
| BullMQ(基于 Redis) | 中 | 生产级 Node 任务队列 | 依赖 Redis |
| RabbitMQ | 高 | 复杂路由、多消费者模式 | 需要单独部署 Erlang |
| Kafka | 很高 | 海量日志流、事件溯源 | 需要 ZooKeeper 集群 |
选 Redis 的硬理由:List 天然是队列(LPUSH 入队 / BRPOP 出队)、操作原子(多个 Worker 同时 BRPOP 每个任务只被一个取走)、成本极低(Redis 往往是项目已有的基础设施)。
核心操作(FIFO + 阻塞消费):
LPUSH task:queue '{"type":"mail","to":"a@b.c"}' # 发任务(左进)
BRPOP task:queue 30 # 收任务(右出,阻塞最多 30s)
为什么用阻塞版 BRPOP 而不是 RPOP + 轮询?
- 轮询:空队列时
sleep(100ms)空转 → CPU 浪费 + 最坏 100ms 才感知新任务。 BRPOP:队列空时进程被 OS 挂起,有新任务立刻唤醒 → 零延迟 + 零 CPU 浪费;5s 超时让 Worker 有机会优雅停机(清 isRunning 标志)。- 多队列按参数顺序优先监听 = 简易优先级队列(先查高优先级队列)。
任务状态为什么用 Hash 而不是 String? 存量状态(status/steps/result)每个 Worker 都想局部更新:String 要“GET 整串→parse→改→stringify→SET”,非原子还可能覆盖并发更新;Hash 支持单字段原子更新(HSET task:abc status running 不影响别的字段)——这正呼应第 3.2 节“HINCRBY/HGET”。
Worker 的经典自测三问:
- 任务执行到一半 Worker 崩了怎么办? BRPOP 取走后任务已出队,会丢失——原生局限。方案:
BRPOPLPUSH(弹出的同时移进 processing 队列,处理完再删)、或直接用 BullMQ 的 ACK+超时重排。 - 多个 Worker 会不会取到同一个任务? 不会——
BRPOP是原子操作,每个任务只会被一个 Worker 取走(单线程模型的天然优势)。 - 优先级怎么实现?
BRPOP [high, normal] 5按参数顺序检查,高优先级队列有任务就先取。
生产到底用啥? 原生 List 够用但没有 ack/重试——生产用 Bull(底层就是 LPUSH/BRPOP,封装了重试/延时/定时/并发/ACK),Cluster 下务必传 Redis.Cluster 实例(坑见第 9 章)。
进度推送(Worker 完成→前端实时看到)靠 SSE + Redis Pub/Sub,可另文展开。
14.2 计数器 / 限流
INCR api:user:1:20260101 # 原子 +1(多实例也安全)
EXPIRE api:user:1:20260101 86400 # 当天有效
固定窗口限流(简单,有临界突刺):
Long c = redis.incr(key); // 本窗口已请求次数
if (c == 1) redis.expire(key, 60); // 第一次才设过期
if (c > 100) throw "限流"; // 60s 内最多 100 次
滑动窗口限流(用 ZSet,更精确,消除临界突刺):
long now = System.currentTimeMillis();
redis.zremrangeByScore(key, 0, now - 60_000); // ① 移除窗口外的老请求
long count = redis.zcard(key); // ② 数窗口内请求数
if (count >= 100) throw "限流";
redis.zadd(key, now, requestId + ":" + now); // ③ 记录本次请求
redis.pexpire(key, 60_000);
原理:每次请求都带时间戳进 ZSet,把“60 秒以前”的成员删掉再数个数——窗口是滑动的,不是死板的整分钟。
14.3 排行榜
ZINCRBY rank:day 5 user:1 # 加分
ZREVRANGE rank:day 0 9 WITHSCORES # Top 10(分数从高到低)
ZRANK rank:day user:1 # 我的实时名次(O(logN),排行榜的灵魂)
14.4 去重
SADD members:user:1 u2 u3 u4 # 加成员(自动去重)
SISMEMBER members:user:1 u2 # 判定是否已存在
SINTER a b # 共同关注(交集)
SCARD members:user:1 # 总数
亿级去重要省内存时,用 HyperLogLog(
PFADD/PFCOUNT,误差 0.81% 以内,固定 12KB)。
番外 · 真实案例串讲:《跨洲缓存》
一篇真实的优化复盘,把本篇的所有知识点在业务里走了一遍: 某跨境 C 端业务(拉美用户、北美机房)首页,SSR 渲染依赖「页面结构 + 投放数据」,用户访问跨区,出现:
- 同一手机访问,语言随机切换(缓存 key 缺语言维度),
- 接口耗时 3 秒(跨区网络 + 无连接池 + 直连模式配置不当)。
优化路径(节选,完整复盘另文):
| 步骤 | 动作 | 消耗时间 |
|---|---|---|
| 排查连接池 | 建立池,消除每次建连 | 3000ms → 200ms |
| 排查部署 | 服务与 Redis 同区域部署,消除跨区 RTT | 200ms → 2ms |
| 再优化 | + 本地 LRU、Pipeline、消除大 key | 趋近内存速度 |
三个互相扣住的道理: ① 最快的请求是不发请求(本地缓存);② 最快的网络,是同机房(物理部署);③ 优化有效≠能反推唯一原因(用排除法、不打压别人)。
第 15 章 · 命令速查(常用 30 个命令)
| 分类 | 命令 |
|---|---|
| String | SET / GET / INCR / DECR / SETEX / MSET / MGET |
| Hash | HSET / HGET / HGETALL / HDEL / HEXISTS / HINCRBY |
| List | LPUSH / RPUSH / LPOP / RPOP / BRPOP / LRANGE / LLEN |
| Set | SADD / SREM / SISMEMBER / SINTER / SUNION / SDIFF / SCARD / SPOP |
| ZSet | ZADD / ZINCRBY / ZRANGE / ZREVRANGE / ZRANK / ZSCORE / ZRANGEBYSCORE |
| Key | EXPIRE / TTL / PERSIST / DEL / EXISTS / SCAN |
| 服务 | PING / INFO / SLOWLOG GET / CLIENT LIST / DBSIZE / FLUSHDB(危险) |
第 16 章 · 排障链路(Redis 慢了从哪查)
感觉慢 → --latency(网络) → SLOWLOG(慢命令) → INFO cpu/memory(负载)
→ INFO persistence(落盘) → CLIENT LIST(连接) → --bigkeys(大Key)
→ 客户端分段打点(序列化)
详见第 7 章(六宗罪详解)与第 9 章(代理 vs 直连)。
第 17 章 · 总结 + 自测
五句话带走:
- Redis = 内存 + 单线程 + 多路复用;和 MySQL 是搭档不是对手。
- 五大结构各司其职:String(缓存/计数/锁)·Hash(对象/字段)·List(队列)·Set(去重)·ZSet(排行/延时)。
- 单线程是双刃剑:没有锁竞争,但一个大 key / 慢命令能阻塞所有人。
- 过期和淘汰是两件事:过期是 key 的 TTL 到期,淘汰是内存满删数据(8 种策略)。
- 缓存 = 用 Redis 的最常见姿势:Cache-Aside + 三大故障(穿透/击穿/雪崩)的防护 + 一致性(删缓存/双删/binlog)。
自测:
- 用 Redis 做计数器时,为什么
INCR比“读出来 +1 再写回去”安全?——INCR是原子操作;“读改写”存在并发覆盖。 KEYS *为什么危险?该用什么?——它是 O(N) 且单线程,会阻塞所有请求;用SCAN游标增量。- 主键索引带来什么好处(这是从 MySQL 反观)?——细节见查询优化/索引相关文章;Redis 的「主键」是 key 本身。
- 缓存里“穿透 / 击穿 / 雪崩”三者谁是“大面积过期”?——雪崩;击穿是“单个热点 key”。
- 在 Cluster 模式下,能否用事务同时写
{user:1}:a和{user:1}:b?——可以(同 hashTag 同 slot);但{user:1}:a与{user:2}:b不行(跨 slot)。 - Redis 存“任务队列”该用什么结构?——List(BRPOP 阻塞读);或 ZSet(带执行时间) 做延时队列。
- 布隆过滤器为什么能“挡住穿透”却不会漏?——它只可能误报“存在”,说“不存在”必准确,所以拦截不漏。
- 逻辑过期和互斥锁哪个读更快?——逻辑过期读不阻塞(返回旧值 + 异步刷),互斥锁要等锁。
- 为什么写操作常用“删缓存”而不是“更新缓存”?——规避并发更新缓存的一致性问题,删了下次读时重建最稳。
- 为什么释放锁要 Lua 校验 value?——防止 A 锁过期后把 B 刚抢到的锁误删。
- 任务跑得比锁有效期长会怎样?——中途锁没了,别人可以进来 → 要用看门狗自动续期(第 13.3 节)。
- 分布式锁能完全替代幂等吗?——不能;锁可能过期/失效,幂等才是兜底(锁是优化、幂等是底线)。
BGSAVE为什么会让读抖一下?——fork 子进程时主进程卡顿 + 写盘 IO(第 7 章罪 3)。- 500 QPS 需要多少条连接?——按 Little’s Law
QPS×RTT/1000理论 1 条,实际 5~20 更稳(第 2 章)。 - 下单后马上查订单,为什么可能查不到?——从库还没复制到(主从延迟)→ 这类“写后读”强制走主库(第 8.3 节)。
- 主从复制能解决写压力吗?——基本不能;写仍只在主库,它解决的是读压力 + 备份高可用。
- Worker 用 BRPOP 取走任务后崩了,任务去哪了?——丢了(原生局限);用 BRPOPLPUSH 或 BullMQ 的 ACK+超时重排(14.1)。
- 为什么不能每次请求都新建一条连接?——建连要 TCP 三次握手+鉴权+建会话,开销大且连接有状态;用连接池借还复用(第 2 章)。
术语表
| 术语 | 一句话 |
|---|---|
| B+ 树 / 跳表 | Redis 用跳表实现 ZSet |
| 跳表 SkipList | ZSet 的底层结构:支持范围查询的有序链表 |
| SDS | Redis 的动态字符串:O(1) 取长度、二进制安全——String 的底层 |
| embstr / raw | String 短/长字符串的两种编码:≤44 字节一次内存分配(只读,改一次转 raw)/ 长字符串 |
| pipeline | 多命令一次发送,减少网络 RTT |
| hash slot | Cluster 分片:16384 个槽 |
| 哨兵 | 自动选新主的高可用组件 |
| flock | 持久化 fork 子进程(会卡主进程) |
| Little’s Law | 连接数 ≈ QPS × 延迟 |
| 连接池 Connection Pool | 预建 N 条连接复用,借/还机制;池满=线上事故经典款 |
| 会话 Session | 一条连接上的“状态集合”(autocommit/隔离级别/临时表),连接断=全没 |
| binlog | 主从复制的载体:主库把每次写记入二进制日志,从库拉取重放 |
评论