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 简单动态字符串,二进制安全

由这张表推出三件事:

  1. INCR 的原子不靠锁——单线程 + 原地加法,“读出来+1再写回去”的并发覆盖竞态根本不存在(呼应第 17 章自测 1)。
  2. INCR 只认“看起来是整数的字符串”——计数器 key 一旦被 SET 成别的字符串,后续 INCR 直接报 WRONGTYPE,整条链路崩。
  3. 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 坑清单

  1. 裸 SET 清 TTL(3.1.2 头号坑)→ 永久 key / 锁失效。
  2. INCR 后没设成 EXPIRE → 永久计数 key:内存涨 + 限流失效。
  3. 缓存回写竞态:两个客户端拿到同一份旧 JSON,各自改完 SET 回去,后写的盖掉先写的 → 用 SET key newval GET(4.0+,原子换值并拿回旧值)或 Lua。
  4. 大 value:String 上限 512MB,但 value 超过 ~10KB 就该按大 key 警惕(第 7 章罪 1);图片/文件本体放对象存储,Redis 只存 URL。
  5. 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
       → 期间父进程照常服务!
       父进程改某页数据 → 才把那一页复制一份给父进程(写时复制)

两个推论:

  1. fork 本身会卡主进程:复制的是页表(不是数据),越大的实例页表越大,卡顿越久(经验值:GB 级实例几十毫秒起步,越大越糟)——这就是第 7 章“罪 3 持久化阻塞”的根源。
  2. 极端时内存可能接近翻倍:快照期间写入越猛,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 持久化常见坑

  1. fork 是三大卡顿之一:BGSAVE、AOF 重写、主从全量同步都会 fork——别同时踩两个(如把 BGSAVE 和 BGREWRITEAOF 定时都设在业务高峰)。
  2. 内存余量没留够:COW 期间内存飙升 → 触发 maxmemory 淘汰、甚至 OOM。容量按“预计数据 + 30%~50%“规划。
  3. 以为 everysec= 不丢数据:它是“最多丢 1 秒”,且磁盘慢时可能阻塞主线程;真的不能丢就 always + SSD + 从库。
  4. 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、maxConnections 10~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(ioredis Redis.Cluster),不能当单机连。

第 9 章 · 代理 vs 直连(云 Redis 的典型抉择)

代理模式(Proxy) 直连模式(Direct)
拓扑/路由 代理自动处理(MOVED/ASK 无感) 客户端自己维护(slots 管理)
连接管理 代理内置连接池 客户端自己配
网络路径 客户端→代理→节点 客户端→节点(更短)
稳定性 稳定低抖动 处理不好反而慢

直连变慢的四个场景:

  1. 客户端没正确处理 MOVED/ASK 重定向(等待超时、反复打到错误节点)。
  2. slots 频繁刷新(slotsRefreshTimeout 大 → 首屏有人卡 10s)。
  3. Bull 不是天生 Cluster 感知——传单机配置会全部写到一个节点(热点+重定向慢):
    // ✅ Bull 要传 ioredis Cluster 实例,不是 { host, port }
    const queue = new Queue('email', { connection: redisCluster });
  4. 无连接池 → 每任务新建连接(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。

解法:

  1. 过期时间加随机抖动:expire = base + random(0..1000),避免整批同时过期。
  2. 多级缓存:Redis 挂/未命中时,还有一份**本地缓存(L1)**扛读。
  3. 限流熔断:DB 扛不住时先限流/熔断,保常规服务,别让 DB 被打死。
  4. 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 脏的坑!

🎯 面试常问:

  1. 穿透/击穿/雪崩怎么区分?——见第 11 章开篇一表。
  2. 先删缓存再写库,为何还可能不一致?并发下谁回填旧值?——见 12.2 时序;用延迟双删。
  3. 防击穿的互斥锁,该给谁加?——只给热点 key;锁用 SETNX(呼应第 13 章)。
  4. 缓存和 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 的经典自测三问:

  1. 任务执行到一半 Worker 崩了怎么办? BRPOP 取走后任务已出队,会丢失——原生局限。方案:BRPOPLPUSH(弹出的同时移进 processing 队列,处理完再删)、或直接用 BullMQ 的 ACK+超时重排。
  2. 多个 Worker 会不会取到同一个任务? 不会——BRPOP 是原子操作,每个任务只会被一个 Worker 取走(单线程模型的天然优势)。
  3. 优先级怎么实现? 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 渲染依赖「页面结构 + 投放数据」,用户访问跨区,出现:

  1. 同一手机访问,语言随机切换(缓存 key 缺语言维度),
  2. 接口耗时 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 章 · 总结 + 自测

五句话带走:

  1. Redis = 内存 + 单线程 + 多路复用;和 MySQL 是搭档不是对手。
  2. 五大结构各司其职:String(缓存/计数/锁)·Hash(对象/字段)·List(队列)·Set(去重)·ZSet(排行/延时)。
  3. 单线程是双刃剑:没有锁竞争,但一个大 key / 慢命令能阻塞所有人。
  4. 过期和淘汰是两件事:过期是 key 的 TTL 到期,淘汰是内存满删数据(8 种策略)。
  5. 缓存 = 用 Redis 的最常见姿势:Cache-Aside + 三大故障(穿透/击穿/雪崩)的防护 + 一致性(删缓存/双删/binlog)。

自测:

  1. 用 Redis 做计数器时,为什么 INCR 比“读出来 +1 再写回去”安全?——INCR 是原子操作;“读改写”存在并发覆盖。
  2. KEYS * 为什么危险?该用什么?——它是 O(N) 且单线程,会阻塞所有请求;用 SCAN 游标增量。
  3. 主键索引带来什么好处(这是从 MySQL 反观)?——细节见查询优化/索引相关文章;Redis 的「主键」是 key 本身。
  4. 缓存里“穿透 / 击穿 / 雪崩”三者谁是“大面积过期”?——雪崩;击穿是“单个热点 key”。
  5. 在 Cluster 模式下,能否用事务同时写 {user:1}:a 和 {user:1}:b?——可以(同 hashTag 同 slot);但 {user:1}:a 与 {user:2}:b 不行(跨 slot)。
  6. Redis 存“任务队列”该用什么结构?——List(BRPOP 阻塞读);或 ZSet(带执行时间) 做延时队列。
  7. 布隆过滤器为什么能“挡住穿透”却不会漏?——它只可能误报“存在”,说“不存在”必准确,所以拦截不漏。
  8. 逻辑过期和互斥锁哪个读更快?——逻辑过期读不阻塞(返回旧值 + 异步刷),互斥锁要等锁。
  9. 为什么写操作常用“删缓存”而不是“更新缓存”?——规避并发更新缓存的一致性问题,删了下次读时重建最稳。
  10. 为什么释放锁要 Lua 校验 value?——防止 A 锁过期后把 B 刚抢到的锁误删。
  11. 任务跑得比锁有效期长会怎样?——中途锁没了,别人可以进来 → 要用看门狗自动续期(第 13.3 节)。
  12. 分布式锁能完全替代幂等吗?——不能;锁可能过期/失效,幂等才是兜底(锁是优化、幂等是底线)。
  13. BGSAVE 为什么会让读抖一下?——fork 子进程时主进程卡顿 + 写盘 IO(第 7 章罪 3)。
  14. 500 QPS 需要多少条连接?——按 Little’s Law QPS×RTT/1000 理论 1 条,实际 5~20 更稳(第 2 章)。
  15. 下单后马上查订单,为什么可能查不到?——从库还没复制到(主从延迟)→ 这类“写后读”强制走主库(第 8.3 节)。
  16. 主从复制能解决写压力吗?——基本不能;写仍只在主库,它解决的是读压力 + 备份高可用。
  17. Worker 用 BRPOP 取走任务后崩了,任务去哪了?——丢了(原生局限);用 BRPOPLPUSH 或 BullMQ 的 ACK+超时重排(14.1)。
  18. 为什么不能每次请求都新建一条连接?——建连要 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 主从复制的载体:主库把每次写记入二进制日志,从库拉取重放

评论

加载中…
评论通过 GitHub 安全存储,提交后稍等片刻显示。