内容总览

Redis 核心与数据结构 思维导图

一、起源:内存数据库的定位

1.1 两种角色:缓存与数据结构服务器

Redis 在实际系统中承担两种角色,二者的配置取向相反,混用是多数线上问题的根源。

角色一:缓存。 位于应用与磁盘数据库之间,用内存的读写速度换掉一次数据库查询。此时 Redis 中的数据是数据库的副本,可以随时从数据库重建。

维度 缓存角色的含义
数据来源 磁盘数据库是唯一数据源,Redis 只保存热点子集
一致性要求 允许短暂不一致,允许读到旧值
丢失容忍度 可以整体丢失,重建后仅表现为一次缓存雪崩
容量约束 数据集可以远大于内存,超出部分靠淘汰策略丢弃
关键配置 淘汰策略(allkeys-lru 或 allkeys-lfu)、TTL、回源保护

角色二:数据结构服务器。 直接使用 Redis 提供的共享数据结构承担分布式场景下的职责,例如全局计数器、排行榜、去重集合、会话存储、简单任务队列、限流器、分布式锁。此时 Redis 中存在应用无法从别处重建的数据。

维度 数据结构服务器角色的含义
数据来源 Redis 自身即数据源,数据库可能只有流水记录
一致性要求 需要原子性操作,读写顺序影响业务结果
丢失容忍度 不能整体丢失,需要持久化与副本
容量约束 数据集必须小于内存,容量规划是硬约束
关键配置 持久化(AOF 与 RDB)、主从复制、noeviction 或仅淘汰易失键

两种角色的结论性差异:

  • 缓存角色的最大风险是全部失效后打穿数据库;数据结构服务器角色的最大风险是数据丢失与内存耗尽导致写入失败。
  • 同一实例混用两种角色时,必须让两类键在淘汰策略上可区分:缓存键一律设置 TTL,持久数据不设置 TTL,并使用 volatile-* 策略,使淘汰只作用于缓存键(见 2.3.2)。
  • 数据安全要求较高时,更彻底的做法是分成两个实例部署,使持久化、淘汰与容量规划互不干扰。

1.2 与磁盘数据库的取舍

维度 内存数据库(Redis) 磁盘数据库(关系型)
访问延迟 内存访问在百纳秒量级,客户端观测到的延迟主要来自网络往返 命中缓存时微秒级,未命中时磁盘随机读在毫秒级
容量成本 单位容量成本高,受单机内存上限约束 单位容量成本低,可扩展到远超内存的数据量
数据结构 键值模型加若干通用结构,无关联查询能力 表与索引,支持关联、聚合与约束
事务能力 命令序列连续执行,不支持回滚,无隔离级别 支持回滚、隔离级别与多语句原子性
持久化保证 快照或命令日志,存在数据丢失窗口 预写日志与检查点,可保证已提交事务不丢
扩展方式 分片扩展,跨分片操作受限制 主从、分库分表或分布式数据库
适用负载 高频读、原子计数、排序、去重、会话、限流 全量数据存储、复杂查询、强事务需求

取舍结论:

  • Redis 不承担全量数据存储与复杂查询。需要关联查询、多条件过滤与严格事务的部分应留在磁盘数据库。
  • Redis 承担的是高频访问的读路径与需要原子语义的单键操作。把数据库的聚合计算搬进 Redis 时,需要同时确认数据结构表达能力是否足够(例如多维排序需要把排序维度编码进 zset 的 score)。
  • 两者的角色界限在变化:当业务把 Redis 当作唯一数据源时,持久化、副本与备份的要求会提升到接近数据库的水平,此时架构上需要按第 1.1 节的角色二对待。

1.3 单线程为什么仍然足够快

Redis 用单个线程执行全部命令,却能达到数万到十万级 QPS,原因有四点:

  1. 数据在内存中:命令执行不涉及磁盘寻道与随机读,也不需要等待 IO 完成。
  2. 无锁:单线程执行命令,不需要加锁与解锁,也没有多线程之间的上下文切换与缓存行失效开销。
  3. 数据结构针对内存优化:紧凑编码(listpack、intset、SDS)使数据集中存放,遍历时的缓存命中率高,常见操作复杂度接近 O(1) 或 O(log N)(见 2.2)。
  4. 事件驱动加 IO 多路复用:一个线程用 epoll 管理大量连接,避免每连接一线程的栈空间与调度开销;采用非阻塞 IO,单个慢客户端不会占用线程。

需要补充的边界:

  • 单线程快的前提是每条命令都足够短。一条命令的耗时就是所有其他请求的等待时间,因此使用方式的约束比硬件规格更重要(见 2.1.4)。
  • 瓶颈通常不在 CPU 指令执行,而在网络带宽、内存带宽与持久化的磁盘 IO。当网络吞吐打满单核时,才需要引入多线程 IO(见 2.1.3)。
  • Redis 6.0 起把 socket 读写与协议解析交给 IO 线程,命令执行与数据访问仍在主线程,因此"单线程模型"这一表述在 6.0 之后指命令执行路径而非整个进程。

二、原理

2.1 线程模型与事件循环

2.1.1 主线程的职责

主线程运行事件循环(ae),在循环中依次完成:

  1. 处理就绪的文件事件:接受新连接、读取请求、解析命令、执行命令、把回复写入输出缓冲、写回 socket;
  2. 处理定时任务(serverCron):过期键的定期删除、客户端超时检测、持久化与重写的状态检查、复制状态维护、内存统计刷新等;
  3. 在事件循环的间隙执行内存淘汰检查,并在条件满足时把待写数据刷盘(AOF 的 fsync 策略)。

定时任务的执行频率由 hz 控制,默认 10,即每 100 毫秒一次。hz 提高会使过期键与超时的处理更及时,代价是空闲时的 CPU 占用上升;dynamic-hz 开启后空闲时会降低频率。

事件循环(简化)

        ┌──────────────────────────────────────────────┐
        │  aeMain: while(1) {                          │
        │    处理定时任务(过期扫描、超时、复制维护)  │
        │    计算最近的就绪事件超时                    │
        │    epoll_wait 等待就绪的 fd                  │
        │    处理读事件:读 socket → 解析 → 执行命令   │
        │    处理写事件:把回复缓冲写回 socket         │
        │    检查 maxmemory,必要时执行淘汰            │
        │    按 appendfsync 策略刷 AOF 缓冲            │
        │  }                                           │
        └──────────────────────────────────────────────┘
            单线程串行,任一环节耗时长都会推迟后续环节

2.1.2 IO 多路复用

多路复用解决的是"一个线程如何同时管理大量连接"的问题:

  • 单线程把所有连接的 socket 注册到多路复用器,由内核告知哪些 fd 就绪,只处理就绪的连接,不为空闲连接付出轮询成本。
  • Linux 上使用 epoll,无 fd 数量上限;早期的 select 受 FD_SETSIZE 限制(通常 1024)。
  • 读写 socket 均为非阻塞模式。若采用阻塞读写,一个慢客户端会占住整个线程,其他连接全部等待。
  • 多路复用只解决"知道哪个连接有数据",不解决"一条命令执行慢",后者仍需靠命令与数据规模控制。

2.1.3 多线程 IO 的引入与边界

Redis 6.0 引入 IO 线程,把可并行的网络处理从主线程剥离:

# 主线程之外的 IO 线程数量,1 表示不启用多线程 IO
io-threads 4
# 是否由 IO 线程承担读(协议解析),默认关闭
io-threads-do-reads yes
  • 并行的部分:socket 读、协议解析、回复写入。
  • 仍由主线程串行执行的部分:命令查找、命令执行、数据访问、过期与淘汰、持久化相关的状态变更。
  • 生效边界:仅在网络吞吐打满单核时有效;命令本身耗 CPU 或操作大 key 时没有收益,因为瓶颈不在网络处理。
  • 取值建议:不超过 CPU 核数减一,通常取 4 到 8;线程数过多会增加线程间同步与上下文切换成本。
  • 另有若干后台线程(bio)承担会阻塞主线程的收尾工作:关闭大文件、AOF 的 fsync(everysec 模式下由后台线程执行)、惰性内存释放(UNLINK 与 lazyfree-* 配置)。

2.1.4 慢命令为何阻塞全局

由于命令串行执行,一条命令的执行时间等于同一实例上所有其他客户端的额外等待时间。常见的阻塞来源:

来源 具体操作 阻塞时长的影响因素
全量遍历类命令 KEYS、SMEMBERS、HGETALL、LRANGE 0 -1、ZRANGE 0 -1、SORT、FLUSHALL(同步执行) 键空间或集合的元素数量,随数据规模线性增长
大 key 单点操作 读取或写入超过数 MB 的 string、长度上万的 list 与 hash key 的字节数与编码转换成本
脚本执行 Lua 脚本中的循环与遍历 脚本内的操作规模
阻塞式调试命令 DEBUG SLEEP、DEBUG JMAP、MONITOR 的大量输出 人为指定或流量规模
fork 引起的停顿 BGSAVE、BGREWRITEAOF、主从全量同步的 RDB 生成 内存量决定页表复制耗时,主线程在 fork 期间阻塞
AOF 同步刷盘 appendfsync always 磁盘的 fsync 延迟,直接叠加到每条写命令
内存淘汰 达到 maxmemory 时的淘汰循环 淘汰策略与数据规模,大 key 淘汰的释放成本更高

影响范围:

  • 单实例上的阻塞影响该实例的全部客户端与全部命令,不区分业务。
  • Cluster 模式下阻塞只影响该节点负责的槽,因此跨槽的业务仍可能部分受影响。
  • 排查入口是慢日志(SLOWLOG)与延迟监控(LATENCY),二者记录的是命令执行时间与事件延迟,不含网络时间(见 3.1.4)。

2.2 数据结构与底层编码

2.2.1 九种结构总览

结构 语义 典型命令 主要操作复杂度 底层编码
string 二进制安全的字节串,也可作为整数与浮点数使用 SET、GET、INCR、APPEND、GETRANGE、SETEX SET/GET 为 O(1),APPEND 均摊 O(1),GETRANGE 为 O(N) int、embstr、raw
list 有序、可重复的双向链表语义,支持两端插入删除 LPUSH、RPUSH、LPOP、RPOP、LRANGE、LTRIM 两端操作为 O(1),LINDEX 为 O(N),LRANGE 为 O(S+N) quicklist(由 listpack 节点组成)
hash 字段到值的映射,适合表示对象 HSET、HGET、HDEL、HGETALL、HINCRBY、HSCAN 单字段操作为 O(1),HGETALL 为 O(N) listpack、hashtable
set 不重复元素集合,支持交并差 SADD、SREM、SISMEMBER、SMEMBERS、SINTER、SINTERCARD 增删与判断为 O(1),SMEMBERS 为 O(N),集合运算为 O(N*M) intset、listpack、hashtable
zset 带分数的有序集合,按分数排序并支持范围查询 ZADD、ZSCORE、ZRANGE、ZRANGEBYSCORE、ZRANK、ZINCRBY ZADD 为 O(log N),ZSCORE 为 O(1),范围查询为 O(log N + M) listpack、skiplist 加 hashtable
bitmap 基于 string 的位操作,把位当布尔使用 SETBIT、GETBIT、BITCOUNT、BITOP、BITPOS 按位读写为 O(1),统计与运算为 O(N) string 的 raw 编码
HyperLogLog 基数估算,只计数不保存原始元素 PFADD、PFCOUNT、PFMERGE 添加为 O(1),多键统计为 O(N) 稀疏与密集两种表示,上限 12KB
GEO 地理位置索引,支持半径与矩形范围查询 GEOADD、GEODIST、GEOPOS、GEOSEARCH GEOADD 为 O(log N),查询为 O(log N + M) 有序集合,score 为 52 位 geohash 整数
stream 追加写的日志式结构,支持消费组与未确认列表 XADD、XREAD、XREADGROUP、XACK、XPENDING、XAUTOCLAIM、XTRIM 追加为 O(1),范围读取为 O(log N + M) 基数树(rax)加 listpack 节点

补充说明:

  • 九种结构共享同一个键空间,键名冲突需要靠命名约定避免;string 是其余结构的底座,bitmap 与 HyperLogLog 实际都存放在 string 类型的值中。
  • 复杂度中的 N 是单个键内的元素数量,不是键空间大小。因此"单键元素数量"是容量与延迟规划的第一指标。
  • KEYS、HGETALL、SMEMBERS 等的风险来自 N 过大,而不是命令本身有问题;限制单键规模即可控制风险。
  • SINTERCARD(7.0 起)在只需要交集基数时避免构造结果集,比 SINTER 更适合大集合场景。

2.2.2 各结构的语义要点

string

  • 二进制安全,可存放序列化后的对象、图片字节等,但大 value 会放大网络与内存开销。
  • 数值语义:INCR、DECR、INCRBYFLOAT 直接对存储的字符串做整数或浮点运算,溢出会报错而不回绕。
  • 过期与条件写:SET 支持 EX、PX、KEEPTTL、NX、XX,是实现简单分布式锁与幂等标记的常用组合。
  • 长度上限 512MB,实践中应远低于该值。

list

  • 支持两端 O(1) 插入删除,适合栈、队列与最新列表;中间插入为 O(N)。
  • LTRIM 配合 LPUSH 可实现固定长度的最新 N 条列表。
  • 阻塞版本 BLPOP、BRPOP、BLMOVE 可用于简单的阻塞队列,但缺少确认与重投机制,可靠性接近发布订阅(见 2.7.1)。

hash

  • 字段级读写避免整体序列化与反序列化,适合对象的部分更新。
  • 不适合无限增长的 field 集合(例如以用户 ID 作为 field 的全量映射),这会形成大 key。
  • 字段数量小时使用 listpack 编码,内存开销低于同等规模的独立键。

set

  • 去重、存在性判断、交并差运算;SPOP 可实现随机抽样与抽奖类逻辑,SRANDMEMBER 只读不删除。
  • 大集合的 SMEMBERS 会阻塞,遍历应使用 SSCAN。
  • SINTERCARD 与带 LIMIT 的集合运算可避免构造结果集。

zset

  • 分数为双精度浮点,同分时按成员字典序排序;需要稳定排序时把序号或时间戳编码进分数的小数部分。
  • 排行榜、延时任务(score 为到期时间戳)、滑动窗口限流(score 为请求时间)是三类典型用法。
  • ZRANGEBYSCORE、ZRANGE、ZRANGEBYLEX 分别按分数、下标与字典序范围查询。

bitmap

  • 用位表示布尔状态,内存占用为位数除以 8,适用于签到、活跃标记、特征位图。
  • 偏移量上限为 2^32 位(约 512MB),偏移量过大时中间位会按 0 补齐,造成内存浪费。
  • 按天分键存储后可用 BITOP 汇总出周活、月活。

HyperLogLog

  • 标准误差约 0.81%,单个键最多占用 12KB,无论基数多大都近似恒定。
  • 只能估算基数,不能取回元素,也不能判断单个元素是否存在;需要该能力时改用 set 或 bitmap。
  • 元素数较少时使用稀疏表示以节省内存,超过阈值后转为密集表示。

GEO

  • 底层是有序集合,分数为 geohash 编码,因此可以与其他 zset 命令混用(如用 ZRANGE 删除范围内的成员)。
  • 距离计算按球面模型,GEOSEARCH 支持 FROMMEMBER/FROMLONLAT 与 BYRADIUS/BYBOX。
  • 结果默认受距离排序且可限制返回数量;大数据量下应限制返回条数,避免一次性拉取。

stream

  • 每条消息有单调递增的 ID(毫秒时间戳加序号),支持范围读取与 XREAD BLOCK 阻塞拉取。
  • 消费组维护待确认列表(PEL),消息处理失败可由 XCLAIM 或 XAUTOCLAIM 重新分配,具备确认与重投语义。
  • 长度由 XADD 的 MAXLEN/MINID 或 XTRIM 控制,不控制会造成无界增长。
  • 与消息中间件的对照见 消息队列基础与模型 第 2.1 节。

2.2.3 底层编码与转换条件

编码由数据规模与内容自适应切换,切换是单向的:一旦转换为更通用的编码,即使后续元素被删除也不会回退。查看编码使用 OBJECT ENCODING key。

结构 编码 触发条件 相关配置
string int 值可被解析为 64 位整数且长度不超过 20 字节 无
string embstr 长度不超过 44 字节的字符串,内存与对象在一次分配中完成 无
string raw 长度超过 44 字节,或对 embstr 执行 APPEND、SETRANGE 等写操作 无
list quicklist 始终使用;每个节点是一个 listpack list-max-listpack-size(负数表示按字节上限,-2 为 8KB)
hash listpack 字段数不超过 hash-max-listpack-entries(默认 128)且所有字段名与值长度不超过 hash-max-listpack-value(默认 64) 同上
hash hashtable 上述任一条件不满足 同上
set intset 全部元素为整数且元素数不超过 set-max-intset-entries(默认 512) 同上
set listpack 非整数元素的小集合(7.2 起),受 set-max-listpack-entries(默认 128)与值长度 64 约束 同上
set hashtable 元素数量或内容超出上述限制 同上
zset listpack 元素数不超过 zset-max-listpack-entries(默认 128)且成员长度不超过 zset-max-listpack-value(默认 64) 同上
zset skiplist 加 hashtable 上述任一条件不满足;hashtable 提供 O(1) 的分数查找,skiplist 提供有序范围查询 同上

转换条件的实践含义:

  • 阈值是可配置的,改动阈值会影响内存与 CPU 的取舍:调大阈值能提高内存利用率,代价是单次操作的扫描量上升。
  • 编码切换发生在单次写入命令中,元素数量恰好跨过阈值时该命令的耗时明显高于其他命令,属于慢日志的常见来源。
  • 判断内存是否异常时,先看编码:同样的元素数量,listpack 与 hashtable 的内存占用差数倍。
  • 键刚被创建时不含任何元素,此时编码无法判断,需要写入元素后再查看。

2.2.4 选型建议

需求 推荐结构 理由与注意点
计数、限流 string 的 INCR 加 EXPIRE 单键操作原子且 O(1);需要滑动窗口时改用 zset 记录时间戳
排行榜、延时任务 zset 按分数排序与范围查询;同分需要稳定顺序时把序号编码进分数
对象的部分字段更新 hash 字段级读写,避免整体序列化;控制字段数量避免形成大 key
整体读写的小对象 string 一次往返完成,减少命令数量;值过大时考虑压缩或只存引用
去重与集合运算 set 判断与增删为 O(1);只需基数估算时改用 HyperLogLog
大量布尔标记与活跃统计 bitmap 内存占用为位数除以 8;按日分键后用 BITOP 汇总
位置检索 GEO 底层为 zset,可按距离排序并限制返回条数
需要确认与重投的队列 stream 消费组与待确认列表提供确认语义;简单队列可用 list
需要严格有序的集合 无原生支持 用 zset 以分数编码顺序,或由应用侧维护

键模型层面的建议:

  • 一个业务对象一个键适合读多写全量的场景;当对象数量达到百万级时,键本身的内存开销(每个键在百字节量级)与遍历成本会明显上升,可改为 hash 分桶,把固定数量的对象放在同一个 hash 中。
  • 分桶的关键是"单桶元素数量有界"。把全部用户放进一个 hash,等于制造一个大 key。
  • 键数量与单键规模是同一枚硬币的两面:键太少会导致单键过大,键太多会放大固定开销,两者都需要在设计阶段量化。

2.3 过期与淘汰

2.3.1 过期键的删除策略

Redis 的过期不是定时器,而是两种删除策略的组合:

惰性删除。 每次访问键时检查是否过期,已过期则删除并返回空结果(等价于键不存在)。

  • 优点:不产生额外的 CPU 开销,只对真正被访问的键付出成本。
  • 缺点:长期不被访问的过期键会一直占用内存,used_memory 与 expires 计数不会因 TTL 到期而立即下降。

定期删除。 事件循环的定时任务中抽样检查带 TTL 的键并删除已过期者。

  • 每轮默认从带 TTL 的键中抽样 20 个,若其中过期键的比例超过 25% 则继续抽样,直到比例下降到阈值以下或达到单轮时间上限。
  • 抽样范围是设置了 TTL 的键,不会遍历全部键,因此不会因键数量庞大而阻塞。
  • 慢周期与快周期配合,在 CPU 占用与清理及时性之间取舍。

两者关系与结论:

  • 过期键最终会被删除,但删除时刻与 TTL 到期时刻之间存在延迟,延迟取决于 hz、过期键比例与访问模式。
  • TTL 不能被当作精确定时器使用。需要精确调度时,用 zset 的 score 排序配合轮询,或使用 stream。
  • 从节点不主动删除过期键,而是等待主节点删除后同步的 DEL/UNLINK 命令,以避免主从在同一时刻对同一键给出不同结果。因此在从节点上,逻辑上已过期的键可能仍能被读到,从节点上的读一致性需要按此评估(见 Redis 高可用与集群 第 3.1 节)。
  • 键被实际删除时产生 expired 事件(需开启 keyspace 通知,见 2.7.2)。

2.3.2 maxmemory 与八种淘汰策略

maxmemory 定义内存使用的阈值,maxmemory-policy 定义达到阈值后的行为,二者必须成对配置。

策略 淘汰范围 选择依据
noeviction 不淘汰,写入返回 OOM 错误,读与删除仍可用 数据不可重建,宁可写入失败也不丢数据
allkeys-lru 全部键,近似最近最少使用 纯缓存场景的默认选择,访问局部性明显
allkeys-lfu 全部键,按访问频率淘汰低频键 访问频率差异大、存在长期热点键的场景
allkeys-random 全部键,随机淘汰 键的访问概率接近,且希望淘汰开销最低
volatile-lru 仅设置了 TTL 的键,近似最近最少使用 同一实例混用缓存与持久数据,用 TTL 区分两类键
volatile-lfu 仅设置了 TTL 的键,按访问频率淘汰 同上,且访问频率差异大
volatile-random 仅设置了 TTL 的键,随机淘汰 同上,且访问概率接近
volatile-ttl 仅设置了 TTL 的键,优先淘汰剩余生存时间最短者 键有明确时效语义,越早过期越先淘汰

机制要点:

  • LRU 与 LFU 都是近似实现。LRU 通过 maxmemory-samples(默认 5)指定采样数量,在采样池中选择最久未使用者,采样数量越大越接近真实 LRU,代价是每次淘汰的 CPU 开销上升。
  • LFU 为每个键维护访问计数,lfu-log-factor(默认 10)控制计数增长速度,lfu-decay-time(默认 1 分钟)控制计数衰减。LFU 更适合"少数键长期被高频访问、大量键只被访问一次"的分布。
  • volatile-ttl 淘汰的是"剩余生存时间最短"而不是"最早创建"的键,语义上等价于按 TTL 排序淘汰。
  • 淘汰并非每条命令都触发,而是在处理命令前检查内存使用量,超限时循环淘汰,直到低于阈值或已无可淘汰的键。若策略为 volatile-* 且所有键都没有 TTL,行为退化为 noeviction。
  • 淘汰大 key 时同步释放内存会造成停顿,lazyfree-lazy-eviction yes 把释放放到后台线程执行,代价是内存回收滞后,短时间内容易再次触发淘汰。
  • maxmemory-clients(7.0 起)限制所有客户端输出缓冲的总量,在内存达到上限时优先断开占用缓冲最多的客户端,避免慢消费者把实例拖入淘汰。

选择建议:

  • 纯缓存使用 allkeys-lru;若热点键稳定且命中率不理想,改用 allkeys-lfu。
  • 同一实例保存不可重建的数据时,用 volatile-lru 或 volatile-lfu,并强制要求所有缓存键设置 TTL;同时把无 TTL 键的数量纳入巡检(见 3.2.1)。
  • 数据完全不可丢弃时使用 noeviction,并用容量告警、限流与扩容保证不会真正触达上限,而不是依赖淘汰。

2.3.3 过期精度与内存碎片

  • 过期精度受 hz 与抽样量影响,实际删除时间晚于 TTL 到期时间。基于过期事件驱动的业务逻辑(如订单超时)需要容忍这一延迟,或改用 zset 轮询。
  • 频繁创建与删除键、键的大小分布差异大、编码切换造成的重新分配,都会产生分配器碎片。
  • 碎片程度用 mem_fragmentation_ratio(used_memory_rss 除以 used_memory)判断:大于 1.5 说明碎片较多,可考虑开启在线整理;小于 1 说明部分内存已被换出到 swap,性能会明显下降。
  • 在线整理通过 activedefrag yes 开启,相关参数控制触发阈值与单轮占用 CPU 的比例(见 2.8.2)。

2.4 持久化

2.4.1 RDB:时间点快照

触发方式

方式 说明
配置自动触发 save <秒> <变更次数> 的组合,满足任一条件即触发
BGSAVE 命令 手动触发后台保存,立即返回
SAVE 命令 前台保存,阻塞整个实例,线上禁用
主从全量同步 主节点为生成 RDB 而自动执行 BGSAVE
优雅关闭 SHUTDOWN 时若配置了保存点则执行一次保存

快照流程

  1. 主线程 fork 出子进程,主线程在 fork 期间阻塞,阻塞时长与内存量相关;
  2. 子进程把当前内存数据序列化写入临时文件;
  3. 主线程继续处理请求,此期间的写操作触发写时复制,被修改的内存页被复制一份供子进程读取;
  4. 子进程写完后原子替换旧文件,主线程更新状态。

写时复制的代价

  • fork 采用写时复制(Copy On Write),父子进程初始共享全部内存页,只有在页被修改时才复制,因此 fork 本身不需要额外内存,但 kfork 需要复制页表,内存越大耗时越长。
  • 快照期间若写入量很大,最坏情况下大部分页都会被复制,内存占用可能接近翻倍。因此需要预留内存,并配置 vm.overcommit_memory=1 允许内存过度承诺。
  • 建议关闭透明大页(THP),否则写时复制的单位从 4KB 变为 2MB,会放大内存复制量(见 linux: 内存管理 的 2.13 节)。
  • 一次快照期间若内存增长超出预留量,可能触发 OOM Killer 杀掉 Redis 进程,表现为实例整体丢失。

文件与恢复

  • 输出是单一紧凑的二进制文件,默认名为 dump.rdb,存放在 dir 指定目录。
  • 恢复时直接载入内存,速度远快于重放命令,适合做冷备与快速拉起。
  • 内容是某一时刻的完整快照,快照间隔内的写入会全部丢失。
# 自动保存点:900 秒内至少 1 次变更、300 秒内至少 10 次、60 秒内至少 10000 次
save 900 1
save 300 10
save 60 10000
# 保存失败后是否停止写入,用于避免"持久化已失效但无人发现"
stop-writes-on-bgsave-error yes
# 是否压缩字符串对象,压缩会消耗 CPU 换来更小的文件
rdbcompression yes
# 是否校验文件完整性
rdbchecksum yes
# 快照文件名与存放目录
dbfilename dump.rdb
dir /var/lib/redis

2.4.2 AOF:命令日志

写入流程

  1. 命令执行完成后,把该命令以 RESP 格式追加到 AOF 缓冲(aof_buf);
  2. 在事件循环的固定环节把缓冲写入文件(write);
  3. 按刷盘策略决定何时调用 fsync 把数据落到磁盘。

三种刷盘策略

取值 行为 数据丢失窗口 性能影响
always 每个事件循环都执行 fsync 后才继续 接近 0,最多丢失一条正在执行的命令 吞吐显著下降,受磁盘 fsync 延迟支配,通常降低一个数量级
everysec 由后台线程每秒执行一次 fsync 最多约 1 秒,极端情况下接近 2 秒 性能损耗小,是默认与最常用的选择
no 只 write 不主动 fsync,交由操作系统回写 通常约 30 秒,取决于内核脏页回写参数 性能最好,但丢失窗口不可控

补充说明:

  • everysec 的实现在写入量大、磁盘慢时可能出现 fsync 堆积,此时主线程会等待上一轮 fsync 完成,表现为周期性延迟抖动。
  • no-appendfsync-on-rewrite yes 让重写期间不执行 fsync,避免与后台重写的磁盘 IO 竞争,代价是重写期间丢失窗口放大。
  • 建议把 AOF 所在磁盘与数据盘隔离,并避免与该实例的 RDB 文件写在同一条性能较差的磁盘路径上。

重写

  • AOF 记录的是命令,文件会随写入量持续增长,需要重写为表示当前数据集的最小命令集合。
  • 重写由 BGREWRITEAOF 手动触发,或由 auto-aof-rewrite-percentage(相对上次重写后的增长比例,默认 100)与 auto-aof-rewrite-min-size(默认 64MB)自动触发。
  • 重写同样 fork 子进程:子进程基于当时的数据集生成新的 AOF;重写期间的新写入同时追加到原 AOF 与重写缓冲(aof_rewrite_buf);子进程完成后,主线程把重写缓冲追加到新文件末尾并原子替换旧文件。因此重写不会丢失重写期间的写入。
  • Redis 7.0 起 AOF 采用多文件结构:一个基础文件(base,默认以 RDB 格式保存全量数据)加一个或多个增量文件(incr),由 manifest 文件索引,重写时新建基础文件而不重写历史增量文件,减少重写期间的磁盘放大。
  • 文件损坏时用 redis-check-aof --fix 修复,通常只能修复尾部截断;aof-load-truncated yes 允许启动时忽略尾部不完整的命令。
appendonly yes
appendfsync everysec
# AOF 文件名前缀与存放目录(7.0 起增量文件位于 appenddirname 指定的子目录)
appendfilename "appendonly.aof"
appenddirname "appendonlydir"
# 重写触发条件
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
# 重写期间不执行 fsync,避免磁盘 IO 竞争
no-appendfsync-on-rewrite no
# 启动时允许忽略尾部截断的命令
aof-load-truncated yes

2.4.3 混合持久化

混合持久化把两种格式放在同一个 AOF 文件(7.0 之后是同一个 AOF 目录)中:

  • 4.0 引入 aof-use-rdb-preamble yes:AOF 重写后的文件以 RDB 格式保存全量快照作为前导,其后的增量以 AOF 命令追加。
  • 7.0 起多文件 AOF 的基础文件默认即为 RDB 格式,无需再单独开启该参数。
  • 效果:恢复速度接近 RDB(直接载入快照而非重放全部历史命令),数据丢失窗口接近 AOF(增量命令仍在按刷盘策略落盘)。
  • 代价:文件不再是有明文的命令流,人工审计与部分解析工具不再适用,排障时需要依赖 redis-check-aof。

2.4.4 两种方式的恢复速度与丢失窗口对照

方案 文件内容 相对文件大小 恢复速度 数据丢失窗口 主要代价
仅 RDB 某一时刻的完整数据集快照 最小 最快,直接载入内存 最近一次快照之后的所有写入 fork 停顿与写时复制的内存放大
RDB 加 AOF everysec 快照前导加增量命令 较大 较快(先载入快照再重放少量命令) 约 1 秒 恢复期需重放命令,文件更大
仅 AOF everysec 纯命令流 大 慢,需要重放全部命令 约 1 秒 恢复时间长,文件持续增长需要重写
仅 AOF always 纯命令流 大 慢 接近 0 每条写命令都要 fsync,吞吐大幅下降
仅 AOF no 纯命令流 大 慢 约 30 秒,不可控 丢失窗口依赖操作系统参数

载入顺序

  • appendonly yes 时启动优先载入 AOF,因为 AOF 通常比 RDB 更新;关闭 AOF 时才载入 RDB。
  • 开启 AOF 后原有的 RDB 文件仍会按保存点继续生成,可用于备份,但不再是启动时的载入来源。

2.5 事务与 Lua

2.5.1 MULTI 与 EXEC

  • MULTI 之后的命令进入队列,服务端返回 QUEUED,EXEC 时按入队顺序依次执行。
  • 执行期间不会插入其他客户端的命令,这一点的实现基础是命令串行执行,因此事务的"隔离性"来自单线程模型而非锁或多版本控制。
  • DISCARD 清空队列并退出事务状态,UNWATCH 清除监视。

不具备回滚是 Redis 事务与数据库事务最大的差别:

错误类型 发生阶段 结果
命令不存在、参数个数错误、语法错误 入队阶段 服务端返回错误,EXEC 拒绝执行整个事务(2.6.5 起的行为)
类型错误(如对 string 执行 LPUSH)、参数取值越界 执行阶段 该条命令返回错误,其余命令继续执行,已执行的命令不回滚

因此:

  • 事务不能用于"失败即撤销"的场景。业务上的约束校验应在应用侧完成,或改用 Lua 脚本在服务端做前置判断。
  • 事务保证的是"命令之间不被穿插",适合需要连续性但不需要回滚的操作,例如同时更新多个计数。
  • 事务中的命令数量与单键规模仍需控制,否则等同于一次批量阻塞。

2.5.2 WATCH 与乐观锁

  • WATCH key 记录被监视键的版本,EXEC 执行前检查版本是否变化;变化则整个事务不执行并返回空。
  • 典型用法是读-改-写(CAS):读取当前值,WATCH,重新计算,MULTI 后写入,失败则重试。
  • 使用注意:
    • 监视的键被其他客户端修改、被过期删除,都会导致事务失败。监视带 TTL 的键时需要把过期视为正常竞争,纳入重试逻辑。
    • EXEC、DISCARD、UNWATCH 会清除全部监视;连接断开后服务端自动清除。
    • 冲突概率随并发度上升,重试次数与退避策略必须设置上限,避免形成重试风暴。
    • 单一计数器场景(扣库存、发号)优先使用 INCR、DECR、HINCRBY 等原子命令,不需要事务;WATCH 适用于多键或"读后判断"的逻辑。
  • 更复杂的原子逻辑应使用 Lua 脚本或 Redis 7.0 的函数,避免大量重试。

2.5.3 Lua 脚本

接口与生命周期

命令 作用
EVAL script numkeys key... arg... 直接执行脚本,脚本内容随请求传输
SCRIPT LOAD script 把脚本载入缓存并返回 SHA1,不执行
EVALSHA sha1 numkeys key... arg... 按 SHA1 执行已载入的脚本,只传脚本标识,节省带宽
SCRIPT EXISTS sha1... 检查脚本是否还在缓存中
SCRIPT FLUSH 清空脚本缓存,会导致所有后续 EVALSHA 报 NOSCRIPT
FUNCTION LOAD、FCALL 7.0 起的函数机制,脚本以库的形式持久化并随复制传播

原子性与阻塞

  • 脚本整体作为一条命令执行,执行期间不处理其他客户端请求,因此脚本内的多条读写是原子的。
  • 同时意味着脚本的耗时就是全局阻塞时长。脚本绝不能包含大范围遍历、长时间循环或对多个大 key 的连续操作。
  • 脚本执行中若未产生写入,客户端可发送 SCRIPT KILL 终止;若已产生写入,只能等待脚本结束或执行 SHUTDOWN NOSAVE(会丢失数据,属于 高危 操作)。默认超时由 lua-time-limit(默认 5000 毫秒)控制,超时后脚本仍在运行,其他客户端收到 BUSY 错误。

使用规范

  1. 所有被访问的键必须通过 KEYS 数组传入,不在脚本内拼接键名。集群模式下服务端需要根据 KEYS 判断槽归属,脚本内动态拼键会直接报错。
  2. KEYS 中的多个键必须落在同一槽,集群模式下需配合哈希标签(见 3.6.2)。
  3. 脚本尽量短,只做判断与少量读写。复杂计算移到应用侧。
  4. 明确选择 redis.call(出错即中断并返回错误)或 redis.pcall(返回错误对象,脚本可继续)。脚本出错后已执行的写入不会回滚,因此前置判断要放在写入之前。
  5. 不依赖脚本内的不确定命令产生写入差异。5.0 起默认按脚本效果复制,但仍应避免使用系统时间、随机数直接决定写入内容;需要随机性时由调用方通过 ARGV 传入。
  6. 脚本文件纳入代码仓库并版本化,与业务代码同步评审;EVALSHA 的调用方需要在收到 NOSCRIPT 时重新 SCRIPT LOAD 并重试。
  7. 记录脚本的用途、键模式与预期耗时,作为慢日志排查的对照表。

2.6 Pipeline 与批量

2.6.1 网络往返与吞吐的关系

  • 单条命令的客户端可见耗时 = 网络往返时间(RTT)加服务端执行时间。同机房 RTT 通常在零点几毫秒量级,而服务端执行一条简单命令在微秒量级,因此 RTT 是吞吐的主要成本。
  • 假设 RTT 为 0.5 毫秒,串行执行每秒最多约 2000 次往返。Pipeline 把 100 条命令合并为一次往返,可把吞吐提升两个数量级。
  • Pipeline 减少的是往返次数,不减少服务端的命令执行总量。服务端仍然逐条执行,CPU 与内存开销不变。

2.6.2 Pipeline 与事务、Lua 的区别

维度 批量命令(如 MGET) Pipeline MULTI/EXEC Lua 脚本
网络往返 1 次 1 次(客户端的命令数量可配置) 2 次(MULTI 与 EXEC,中间的入队不产生往返) 1 次(EVALSHA)
原子性 单条命令本身原子 无,命令之间可插入其他客户端命令 有,EXEC 期间不插入其他命令 有,脚本整体执行
服务端逻辑 无 无 无 有,可在服务端做条件判断
失败处理 整条命令失败 单条失败不影响其余 运行时错误不回滚 出错后已执行的写入不回滚
适用场景 同类型多键同槽批量读写 大批量无依赖命令的吞吐优化 需要连续执行的少量命令 需要读后判断的原子逻辑

2.6.3 批量命令的注意事项

  • 单次 Pipeline 的命令条数应设置上限(数百到数千条为宜)。命令过多会同时放大客户端的请求缓冲与服务端的输出缓冲,可能触发 client-output-buffer-limit 导致连接被断开。
  • 普通客户端的输出缓冲默认不限制(normal 类别为 0 0 0),这意味着慢消费的客户端可以持续占用服务端内存。启用 Pipeline 与订阅的场景必须显式配置该限制。
  • Pipeline 中的命令应避免大 key 操作,否则等于把多条阻塞命令排队执行。
  • 客户端必须按序读取全部回复。若中途出现协议错误或超时,连接状态不可恢复,正确做法是断开并重建连接,同时评估该批次中写命令的幂等性。
  • 集群模式下 Pipeline 的命令会按槽分散到不同节点,客户端需要按节点分组发送,不能把跨槽命令放进同一次 Pipeline。
  • 需要"全部生效或全部不生效"语义时必须使用 Lua 脚本,Pipeline 不提供该保证。

用批量命令替代逐条命令

逐条调用 批量替代 说明
循环 SET MSET、MSETNX 单次往返写多个键
循环 GET MGET 单次往返读多个键,返回顺序与请求一致
循环 HGET HMGET 同 hash 的多个字段
循环 SADD SADD key member... 一次调用加多个成员
循环 ZADD ZADD key score member score member... 一次调用加多个成员
循环 DEL DEL key...、UNLINK key... 多键删除;UNLINK 在后台释放内存
遍历全量 SCAN、HSCAN、SSCAN、ZSCAN 增量遍历,不阻塞

集群模式下以上多键命令仍要求所有键同槽,否则返回 CROSSSLOT。

2.7 发布订阅与 keyspace 通知

2.7.1 发布订阅

命令与语义

  • SUBSCRIBE/UNSUBSCRIBE 按频道订阅,PSUBSCRIBE/PUNSUBSCRIBE 按模式订阅,PUBLISH 发布,PUBSUB CHANNELS/NUMSUB/NUMPAT 查询状态。
  • 投递语义是发后即忘:消息不持久化、不重发、无确认。订阅者离线期间的消息全部丢失,因此等价于"至多一次"。
  • 慢订阅者的输出缓冲会持续增长,超过 client-output-buffer-limit pubsub(默认硬限制 32MB,软限制 8MB 持续 60 秒)后连接被服务端断开。
  • RESP2 协议下,进入订阅状态的连接不能执行普通命令,需要为订阅单独建立连接;RESP3(6.0 起)允许在订阅状态下执行其他命令。

集群模式下的行为

  • 7.0 之前,PUBLISH 会被转发到集群内所有节点,订阅者在任意节点都能收到消息;频道与槽无关,代价是全集群广播。
  • 7.0 起提供 SSUBSCRIBE/SPUBLISH,频道按槽分布到具体节点,只在负责该槽的节点及其副本间传播,避免全集群广播。使用分片发布订阅时,生产者与消费者需要落在同一槽。

适用与不适用

场景 是否适用 原因
配置变更通知、缓存失效广播 适用 允许丢失,下一次变更会重新发布
会话状态同步、在线状态广播 适用 单个事件丢失由后续心跳或轮询补偿
任务分发、订单通知 不适用 消息不能丢失,应使用 stream 或消息中间件
需要确认与重投的处理流程 不适用 无确认机制,靠消费端自己实现会重复发明队列

不可丢失的场景应使用 stream(消费组加待确认列表)或专业消息中间件,可靠性设计的通用模型见 消息可靠性与幂等设计。

2.7.2 keyspace 通知

开关与参数

# 默认关闭,按需开启;A 等价于 g$lshzxet 的组合
notify-keyspace-events "KEA"

标志字符含义:

标志 含义
K 发布 keyspace 事件,频道名为 __keyspace@<db>__:<key>
E 发布 keyevent 事件,频道名为 __keyevent@<db>__:<event>
g 通用命令事件,如 DEL、EXPIRE、RENAME
$ string 命令事件
l list 命令事件
s set 命令事件
h hash 命令事件
z zset 命令事件
x 过期事件(expired)
e 淘汰事件(evicted)
t stream 命令事件
m key miss 事件(未命中)
n 新键事件
d 模块键类型事件
A g$lshzxet 的别名,不含 m 与 n

用途

  • 过期驱动的业务逻辑:通过 expired 事件触发订单超时、任务超时、会话清理。
  • 缓存失效通知:数据变更时通知其他实例失效本地缓存。
  • 审计与监控:记录键的创建、删除、淘汰过程。

开销与限制

  • 事件产生在命令执行路径上,由主线程发布,事件量大时直接增加 CPU 占用与网络流量,且事件本身不进入慢日志而可能影响整体延迟。
  • 过期事件在键被实际删除时产生,与 TTL 到期时刻不一致;从节点不产生过期事件;淘汰事件在内存紧张时可能被丢弃,因此不适合作为唯一的数据一致性保证。
  • 集群模式下事件只在键所在的节点产生,订阅方需要订阅全部节点(或使用分片订阅按槽覆盖)。
  • 开启 m(key miss)会为每次未命中产生事件,缓存穿透较多时开销明显,通常不建议开启。

2.8 内存管理

2.8.1 内存构成

used_memory 不只有业务数据,规划容量时需要逐项考虑:

组成 说明 观察方式
数据集 键、值以及编码结构的开销;键名本身也占用内存 INFO memory 的 used_memory_dataset
服务自身开销 服务端数据结构、命令表、客户端连接对象 MEMORY STATS
客户端缓冲 每个连接的输入缓冲(查询缓冲上限 1GB)与输出缓冲(回复、订阅、副本三类上限) CLIENT LIST 的 qbuf、omem
复制缓冲 主节点的复制积压缓冲(repl-backlog-size,默认 1MB)与每个副本的输出缓冲 INFO replication 的 repl_backlog_size
持久化相关 fork 期间的写时复制页、AOF 重写缓冲、RDB 输出 INFO persistence、INFO memory 的 mem_clients_normal 等
碎片 分配器尺寸类造成的 RSS 与 used_memory 差额 mem_fragmentation_ratio
脚本与慢日志 Lua 脚本缓存、慢日志条目(slowlog-max-len) INFO memory 的 used_memory_lua

关键结论:

  • maxmemory 的比较基准是 used_memory,因此副本输出缓冲、复制积压缓冲等也会占用配额。主节点内存吃紧时先淘汰的是业务数据,而副本缓冲仍在增长,这会形成"淘汰→副本落更远→缓冲更大"的恶性循环。
  • 规划容量时不能只看数据集大小,需要按上述各项留出余量(见 2.8.4)。
  • 容器部署时,容器内存限额必须大于 maxmemory 加各项开销,否则 OOM Killer 会在 Redis 自己触发淘汰之前杀掉进程。

2.8.2 内存碎片与整理

判断指标

指标 含义 判读
mem_fragmentation_ratio used_memory_rss 除以 used_memory 1.0 到 1.5 属正常;大于 1.5 说明碎片偏多;小于 1 说明部分内存已被换出到 swap
allocator_frag_ratio 分配器层面的碎片比例 排除 RSS 中与分配器无关的部分后判断
mem_fragmentation_bytes RSS 与 used_memory 的绝对差额 结合总内存判断是否需要干预

产生原因

  • 频繁创建与删除不同大小的键,分配器释放的页无法被其他请求复用。
  • 键的大小分布差异大,或大量的编码切换(如 listpack 转为 hashtable)造成重新分配。
  • 大 key 删除后释放出的大块空间难以被小对象利用。

处理手段

# 在线碎片整理
activedefrag yes
# 碎片差额低于该值时不做整理,避免无意义的 CPU 消耗
active-defrag-ignore-bytes 100mb
# 碎片率上下限:低于下限不整理,高于上限时提高整理强度
active-defrag-threshold-lower 10
active-defrag-threshold-upper 100
# 单轮整理占用的 CPU 比例上下限
active-defrag-cycle-min 1
active-defrag-cycle-max 25
  • MEMORY PURGE 请求分配器(jemalloc)把空闲页交还操作系统,执行期间会短暂占用 CPU,只解决 RSS 偏高的问题,不改变碎片率。
  • 碎片长期无法收敛时采用滚动重启:先重启副本、提升为主、再重启旧主(属 高危 操作,涉及主从切换,回滚方式为切换前记录复制位点并在切换后核对,演练步骤见 Redis 高可用与集群 第 3.2 节)。
  • 关闭透明大页并按实际需求调整分配器参数,可减轻碎片产生的速度(见 linux: 内存管理 的 2.8 节与 2.13 节)。

2.8.3 内存分析命令

命令 用途 注意
INFO memory 总览:used_memory、used_memory_rss、used_memory_peak、碎片率、maxmemory 与策略 采样输出,用于趋势与告警
MEMORY STATS 分项内存构成,含数据集、客户端、复制、碎片 输出项随版本变化,解析时注意兼容
MEMORY USAGE key [SAMPLES n] 单个键的内存占用(含键名与编码开销) 大键取样会低估或高估,SAMPLES 控制精度
MEMORY DOCTOR 内存状态的诊断建议 结论为启发式判断,需人工复核
MEMORY MALLOC-STATS 分配器的内部统计 输出较长,用于碎片定位
redis-cli --bigkeys 抽样扫描各类型中元素数最多的键 基于 SCAN 统计元素数量,不反映字节数,string 类可能遗漏
redis-cli --memkeys 抽样扫描各类型中内存占用最大的键 比 --bigkeys 更贴近真实占用,开销也更大
redis-cli --hotkeys 抽样统计访问频率最高的键 需要淘汰策略为 LFU 才有频率计数;会遍历键空间
SCAN cursor [MATCH] [COUNT] [TYPE] 增量遍历键空间 不阻塞,但只保证遍历期间一直在存在的键被返回
OBJECT ENCODING/FREQ/IDLETIME key 编码、访问频率(LFU)、空闲时间(LRU) 编码是判断内存异常的第一指标

--bigkeys 与 --hotkeys 都会遍历键空间,在实例负载较高时执行需评估影响,建议在副本上执行或限定在低峰窗口。

2.8.4 maxmemory 的取值与主机内存的关系

maxmemory 的取值 = 节点可用内存 − 各项需要预留的余量。

预留项 预估方式
持久化 fork 的写时复制余量 若使用 RDB 或 AOF 重写且快照期间写入量大,需要预留接近数据量的空间,最坏情况按 1 倍数据集估算
内存碎片 按实测 mem_fragmentation_ratio 预留,通常为数据集大小的 10% 到 50%
副本输出缓冲与复制积压 按副本数量、断线时长与写入速率估算;跨机房或大批量同步时明显增大
客户端缓冲 按连接数与单连接缓冲上限估算;未限制输出缓冲的场景需要额外留量
同机其他进程 系统、代理、监控代理、日志组件与容器运行时

实践要点:

  • 常见做法是把 maxmemory 设为节点可用内存的 50% 到 75%,再通过压测验证实际水位;具体比例取决于持久化方式与碎片率。
  • maxmemory 与 maxmemory-policy 必须同时配置。只配 maxmemory 时默认策略为 noeviction,达到上限后所有写命令失败。
  • 用容器内存限额或 cgroups 兜底,但限额要大于 maxmemory 加预留量;限额等于 maxmemory 会让 OOM Killer 抢先杀掉进程,丢失的数据量多于按策略淘汰(OOM 排查方法见 linux: 内存管理 的 3.10 节)。
  • used_memory_peak 记录历史峰值,是判断预留是否足够的直接依据;峰值接近 maxmemory 时说明当前配置缺少缓冲。
  • 内存压力下的三种表现需要区分:触发淘汰(evicted_keys 增长)、写入被拒绝(maxmemory 已满且不可淘汰)、被 OOM Killer 终止(进程消失,实例重启后从持久化文件恢复,丢失最近写入)。三者的处置方式不同,监控指标应分别采集(见 linux: 监控与告警)。

三、实现

3.1 键设计与命令规范

3.1.1 键命名

  • 结构:业务:对象:标识[:字段],用冒号分隔层级,全部小写,避免空格、换行与控制字符。
  • 前缀统一:同一业务线的键使用固定前缀,便于按前缀统计、审计与定向清理。
  • 长度控制:键名本身占用内存,过长会放大内存开销;过短会牺牲可读性。用固定的缩写对照表约束,不随个人习惯变化。
  • 版本化:需要重建数据结构时,用新前缀或版本号切换(如 cache:v2:user:1001),先写新键、切换读取、再清理旧键,避免原地改造导致新旧格式混杂。
  • 禁止项:不使用业务主键直接作为键而不加前缀;不把用户输入原样拼接进键名;不在键名中放入无界长度或高基数的内容(会把一个键变成无数个键,且无法按前缀管理)。
  • 键名中的哈希标签 {} 只在集群模式需要同槽时使用,且需要评估倾斜(见 3.6.2)。

3.1.2 大 key 的识别与建模

判定阈值(经验值,需按实例规格与业务调整)

结构 参考阈值
string 单值超过 10KB
hash、set、zset 元素数超过 5000,或总字节数超过 1MB
list 长度超过 5000
stream 长度超过 10 万条且未配置修剪

危害

  • 单次操作的数据量与耗时上升,直接阻塞主线程;hash 与 zset 在编码转换时(元素数或值长度越过阈值)该次写入的耗时明显高于其他命令。
  • 删除大 key 时同步释放大量内存造成停顿;集群模式下槽迁移的单个键越大会让 MIGRATE 阻塞越久。
  • 持久化与主从同步时放大磁盘 IO 与网络传输;备份文件与复制积压占用量同步上升。
  • 内存碎片更容易产生,键规模越大越难被其他对象复用。

识别方式

# 抽样扫描各类型的最大键(遍历键空间,建议在低峰或副本上执行)
redis-cli --bigkeys
# 抽样扫描内存占用最大的键
redis-cli --memkeys
# 查看单个键的实际内存占用
redis-cli MEMORY USAGE mykey SAMPLES 100
# 抽查某类键的元素数量,配合 SCAN 分批执行
redis-cli --scan --pattern 'user:cart:*' | head -n 100
  • 把大 key 检测纳入定期巡检,记录各次扫描的最大键与阈值超标数量(巡检清单见 linux: 巡检与健康检查)。
  • 应用侧在写入前校验元素数量与值长度,超过阈值时拒绝写入并告警,比事后扫描更可靠。

建模方式

反例 改法
全部用户的购物车放在一个 hash 按用户 ID 取模拆成若干 hash(如 cart:0 到 cart:15),或每个用户一个 hash 并控制单用户规模
一条消息的接收者 ID 全部放进一个 set 按批次或时间窗拆分为多个 set,分页读取
大 JSON 整体存为一个 string 压缩后存储,或只存对象存储的引用地址
无界增长的 list 作为日志缓冲 用 LTRIM 固定长度,或改用 stream 并配置 MAXLEN
热数据与全量数据同一结构无界增长 按时间分键(stat:2026-09-22)并用 TTL 自动清理

删除大 key 属于 高危 操作:DEL 是同步删除,删除超大 hash 或 zset 会在主线程同步释放全部内存,期间阻塞所有请求。执行前确认数据可由上游重建或已完成归档,并优先使用 UNLINK 让释放过程在后台线程完成;回滚方式为删除前导出数据(DUMP 或应用侧备份),删除后无法恢复,无法重建时不得执行。

3.1.3 热 key 的处理

判定:单键的访问量显著高于其他键,或在缓存命中中占比过高。识别方式:

# 需要淘汰策略为 LFU,输出访问频率最高的键
redis-cli --hotkeys
# 查看单键的访问频率与空闲时间
redis-cli OBJECT FREQ mykey
redis-cli OBJECT IDLETIME mykey

也可以在客户端侧按键维度埋点统计,比服务端采样更准确。

处理手段

手段 说明 代价
本地缓存 在应用进程内缓存热点数据,减少到 Redis 的请求量 需要失效通道(如发布订阅),多实例之间存在一致性窗口
读副本分散 把热点键的读请求分散到多个副本 副本可能落后,读到旧值;写仍然集中在主节点
键拆分 把热点键复制为若干副本键(如 hot:1 到 hot:10),读端随机选择,写端同时更新全部副本 写入放大,读一致性需要容忍短暂的多副本不一致
限流与降级 对热点键的访问限流,超过阈值时返回降级结果 影响功能完整性,需要业务侧确认降级语义

热 key 与业务模型强相关(秒杀商品、首页配置、活动开关),应在设计阶段识别并提前准备手段,而不是在故障中临时处理。大 key 与热 key 的建模改造、处置清单与多级缓存的配合方式见 Redis 缓存实践与常见问题。

3.1.4 命令规范与高危命令

禁止或严格限制使用的命令

命令 风险 替代方案
KEYS pattern 全量遍历键空间,O(N) 阻塞 SCAN 迭代;已知键名时直接按名访问;用集合结构显式维护键清单
FLUSHALL / FLUSHDB 清空实例或当前库的全部数据 按前缀 SCAN 加 UNLINK 定向清理;必要时在副本上验证后再执行
HGETALL / SMEMBERS / LRANGE 0 -1 / ZRANGE 0 -1 大集合全量读取,O(N) 阻塞且放大网络传输 HSCAN、SSCAN、ZSCAN 分批;或限制范围与返回条数(LIMIT、COUNT)
SORT 未加 LIMIT 对大集合排序并构造结果集 加 LIMIT,或改为在写入时维护有序结构(zset)
MONITOR 输出全部命令,显著降低吞吐,且会暴露键内容与参数 用 SLOWLOG、LATENCY、COMMANDSTATS 定位问题
DEBUG SLEEP / DEBUG OBJECT / DEBUG JMAP / DEBUG RELOAD 阻塞主线程或改变实例状态 生产环境禁用;需要时用 CONFIG SET 的可观测等价项
SAVE 前台快照,阻塞全部请求 BGSAVE
DEL 大 key 同步释放大块内存造成停顿 UNLINK
CONFIG SET 在线修改关键参数 影响面大且难以回滚 按变更流程执行,先记录原值,验证后 CONFIG REWRITE 固化

FLUSHALL 与 FLUSHDB 属 高危 操作:二者不可撤销,会删除实例或库内全部键,包括未设置 TTL 的持久数据。7.0 起可用 ASYNC 参数把释放放到后台线程,但数据清空的效果不变。执行前必须确认目标实例与库的归属、确认数据存在可用备份(RDB 或 AOF)且在演练环境验证过恢复流程、通知业务侧并在低峰执行;回滚方式为用最近的 RDB 或 AOF 文件恢复(会退回到快照时间点,丢失其后的写入),无可用备份时不得执行。

其余规范

  • 用批量命令替代循环单条调用(见 2.6.3):MGET、MSET、HMGET、多元素 SADD 与 ZADD。
  • 用 EVALSHA 替代在业务代码中拼装多条命令并自行加锁。
  • 不使用 SELECT 切换库做环境或业务隔离:同一个实例的库共享内存配额、淘汰策略与 CPU,集群模式只支持 db0。隔离应使用独立实例或键前缀。
  • 禁止把 redis-cli 的交互式会话用于线上变更,变更命令通过脚本或运维平台执行并留痕。
  • 命令的超时与重试按 3.5.1 的规则处理,写命令默认不自动重试。

3.2 过期与淘汰的配置实践

3.2.1 TTL 设置惯例

  • 所有缓存键都必须设置 TTL。无 TTL 的键在 volatile-* 策略下不受淘汰影响,会持续占用内存直到写入失败。
  • TTL 加随机偏移(例如基础值加 0 到 10% 的随机量),避免大量键在同一时刻过期造成回源压力集中,相关防护见 Spring Boot 实践 的 4.3 节。
  • TTL 取值依据:数据变更频率与业务可接受的陈旧程度。变更频繁的数据取短 TTL 并配合写时更新,变更极少的数据可设置数小时到一天。
  • 会话类数据的 TTL 应大于会话的滑动窗口,并在每次访问时续期;续期操作使用 EXPIRE 而不要重建整个键。
  • 限流与防重放的键使用固定的短窗口(毫秒到秒级),并在窗口结束后自然过期,避免手工清理。
  • 统计无 TTL 键:INFO keyspace 的 expires 字段反映带 TTL 键的数量,与 keys 对比可估算占比;需要精确清单时用 SCAN 配合 TTL 抽样统计。
  • 巡检项:无 TTL 键数量与占比、临近过期键的集中度、expired_keys 的增长速率是否异常(正常运行时应有稳定的过期量)。

3.2.2 淘汰策略选择

用途 推荐策略 理由
纯缓存,数据可完全重建 allkeys-lru 使用简单,对访问局部性敏感的场景效果好
纯缓存,热点集中且长期稳定 allkeys-lfu 低频键不会被偶发访问"洗白",命中率更稳定
缓存与持久数据同实例,缓存键均设 TTL volatile-lru 或 volatile-lfu 淘汰只作用于带 TTL 的键,保护不可重建的数据
键有明确时效且允许按剩余时间淘汰 volatile-ttl 越接近过期的数据越可能已无价值
数据不可丢弃 noeviction 加容量保障 宁可写入报错并告警,也不静默丢弃数据

配置与核对:

# 内存上限,取值依据见 2.8.4
maxmemory 8gb
# 淘汰策略:纯缓存场景
maxmemory-policy allkeys-lfu
# LRU 与 LFU 的采样数量,越大越精确但 CPU 开销越高
maxmemory-samples 5
# LFU 相关参数
lfu-log-factor 10
lfu-decay-time 1
# 淘汰时在后台线程释放内存,避免大 key 淘汰造成停顿
lazyfree-lazy-eviction yes
# 核对当前生效的配置
redis-cli CONFIG GET maxmemory maxmemory-policy maxmemory-samples
# 查看内存水位与淘汰计数
redis-cli INFO memory | grep -E 'used_memory:|used_memory_peak|maxmemory|mem_fragmentation'
redis-cli INFO stats | grep -E 'evicted_keys|expired_keys'

调整 maxmemory 或策略属 高危 操作:在线调低 maxmemory 会立即触发大量淘汰,或在 noeviction 下导致写命令立即失败;调高则可能让节点超出物理内存而被 OOM Killer 终止;把 noeviction 改为 allkeys-* 会在达到上限时开始丢弃原本不可重建的数据。执行前记录原值与当前水位、确认可用内存与容器限额、评估预期淘汰量,并在低峰执行。回滚方式:用 CONFIG SET 传回原值即可立即恢复策略与阈值,已淘汰的键无法恢复(需从数据源重建或从备份恢复),因此变更前后都应核对 evicted_keys 的增量。

3.2.3 过期精度与内存的配合配置

# 定时任务频率,影响过期扫描与超时检测的及时性
hz 10
# 空闲时自动降低 hz,减少空转的 CPU 占用
dynamic-hz yes
# 在线碎片整理
activedefrag yes
active-defrag-ignore-bytes 100mb
active-defrag-threshold-lower 10
active-defrag-threshold-upper 100
active-defrag-cycle-min 1
active-defrag-cycle-max 25
  • hz 提高会让过期键更快被回收、超时连接更快被清理,代价是空闲时的 CPU 占用上升;有大量短 TTL 键的场景可适当提高。
  • 不靠提高 hz 解决过期不及时的问题。若内存被过期键长期占用,说明访问模式导致惰性删除无法触发,应考虑改用定期重建整个键(SET 加 EX 覆盖)而非依赖 TTL 到期。

3.3 持久化配置实践

3.3.1 RDB 与 AOF 的组合建议

角色 建议组合 说明
纯缓存,可整体重建 仅 RDB 或关闭持久化 需评估重启后回源压力;重启后缓存全部失效可能打穿数据库,应准备限流与预热
缓存加可重建数据,丢失窗口可接受 RDB 加 AOF everysec 兼顾恢复速度与丢失窗口,是最常见的选择
数据不可重建,容忍秒级丢失 AOF everysec 加 RDB RDB 用于备份与冷恢复,AOF 用于最近数据
数据不可重建,丢失窗口要求接近 0 AOF always 加 RDB 吞吐下降明显,需要用压测确认业务能承受
有主从且允许切换时丢失少量数据 主从 AOF everysec 副本提供第二次机会,但异步复制仍有丢失窗口

不建议的组合:只开 AOF no 且不配置 RDB(丢失窗口不可控且无备份)、只开 AOF 且长期不重启不重写(文件无界增长,恢复时间不可控)。

3.3.2 刷盘策略与业务容忍度

appendfsync 丢失窗口 延迟影响 适用
always 接近 0 每条写命令叠加一次 fsync 延迟,吞吐通常下降一个数量级 极少数对丢失窗口有硬要求的场景,需先压测
everysec 约 1 秒,极端情况接近 2 秒 后台线程刷盘,正常写入无明显影响,磁盘慢时出现周期性抖动 默认选择,覆盖大多数业务
no 约 30 秒,取决于内核回写参数 影响最小 允许较大丢失窗口、或已有其他恢复手段的场景

补充:no-appendfsync-on-rewrite 在重写期间跳过多余的 fsync,用于缓解磁盘 IO 竞争,代价是重写期间的丢失窗口放大到与 no 相同量级。磁盘 IO 能力充足时保持关闭,可减少丢失窗口。

3.3.3 配置示例与核对

# ===== RDB =====
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb

# ===== AOF =====
appendonly yes
appendfsync everysec
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
no-appendfsync-on-rewrite no

# ===== 物化文件位置 =====
dir /data/redis
# 持久化状态核对
redis-cli INFO persistence | grep -E 'rdb_last_bgsave_status|rdb_last_save_time|aof_enabled|aof_last_bgrewrite_status|aof_last_write_status|aof_current_size|aof_base_size|aof_pending_rewrite'
# 手动触发一次快照与一次重写(低峰执行)
redis-cli BGSAVE
redis-cli BGREWRITEAOF
# 查看最近一次 fork 的耗时,单位微秒
redis-cli INFO stats | grep -E 'latest_fork_usec|rdb_last_cow_size'

判读要点:

  • rdb_last_bgsave_status 与 aof_last_write_status 应为 ok;为 err 时若 stop-writes-on-bgsave-error yes,写命令会被拒绝,属于需要立即介入的状态。
  • latest_fork_usec 与 rdb_last_cow_size 反映 fork 停顿与写时复制的实际内存开销,是判断内存预留是否足够的直接依据。
  • aof_current_size 相对 aof_base_size 的比例接近配置的 auto-aof-rewrite-percentage 时,说明重写即将触发。

3.3.4 恢复流程与校验

# 1. 确认服务已停止,避免文件在恢复过程中被覆盖
systemctl stop redis

# 2. 校验文件完整性
redis-check-rdb /data/redis/dump.rdb
redis-check-aof /data/redis/appendonlydir/appendonly.aof.manifest

# 3. 恢复文件与目录权限(属主需为运行 Redis 的用户)
chown -R redis:redis /data/redis

# 4. 启动并核对载入结果
systemctl start redis
redis-cli INFO persistence | grep -E 'loading|rdb_last_bgsave_status|aof_last_bgrewrite_status'
redis-cli DBSIZE
redis-cli INFO keyspace
  • 启动时若 appendonly yes,优先载入 AOF;因此用旧 RDB 覆盖时若不希望 AOF 生效,需要同时处理 AOF 目录,不能只替换 dump.rdb。
  • 恢复后核对 DBSIZE 与业务量级、抽样校验关键键是否存在与内容正确,再开放业务接入。
  • 备份策略:BGSAVE 完成后复制 RDB 文件是安全的(写入使用临时文件加原子替换);备份应放到独立存储并定期做恢复演练,演练要求与周期见 linux: 备份与灾难恢复。
  • dir 与 dbfilename 的变更属 高危 操作:CONFIG SET dir 后执行 BGSAVE 会把快照写到新目录,若新目录不可写会导致保存失败;更严重的是在错误目录下替换 RDB 文件会让实例在下次启动时载入错误数据。回滚方式为改回原 dir 并用原快照文件覆盖,执行前先备份原目录下的全部持久化文件。

3.4 Lua 脚本与事务的落地

3.4.1 原子计数:固定窗口限流

-- KEYS[1] 限流键
-- ARGV[1] 窗口秒数
-- ARGV[2] 窗口内允许的次数
-- 返回:当前窗口剩余可用次数,-1 表示已超出限制
local current = redis.call('INCR', KEYS[1])
if current == 1 then
    -- 第一次计数时设置窗口过期,保证键最终被回收
    redis.call('EXPIRE', KEYS[1], tonumber(ARGV[1]))
end
local limit = tonumber(ARGV[2])
if current > limit then
    return -1
end
return limit - current

调用与注意事项:

// 使用 DefaultRedisScript 加载脚本文件,交由客户端计算 SHA1 并缓存
DefaultRedisScript<Long> script = new DefaultRedisScript<>();
script.setLocation(new ClassPathResource("lua/rate_limit.lua"));
script.setResultType(Long.class);

Long remain = stringRedisTemplate.execute(
        script,
        Collections.singletonList("rl:order:" + userId),
        String.valueOf(windowSeconds),
        String.valueOf(limit));
  • 固定窗口在窗口边界存在双倍通过的可能(前一个窗口末端与后一个窗口开端连续放行)。需要更平滑的效果时改用 zset 记录时间戳的滑动窗口,代价是内存与命令数量上升。
  • EXPIRE 只在计数为 1 时设置,避免每次请求都重置窗口,否则限流窗口会随持续请求无限延长。
  • 限流键必须设置过期时间,否则会形成大量无 TTL 的键。

3.4.2 原子状态流转:幂等标记与条件更新

-- KEYS[1] 业务状态键(hash)
-- ARGV[1] 业务唯一标识
-- ARGV[2] 目标状态
-- ARGV[3] 幂等标记的过期秒数
-- 返回:1 表示本次完成状态流转,0 表示已处理过(幂等命中)
local done = redis.call('SET', KEYS[1] .. ':done:' .. ARGV[1], '1', 'NX', 'EX', tonumber(ARGV[3]))
if not done then
    return 0
end
redis.call('HSET', KEYS[1], 'status', ARGV[2])
redis.call('HSET', KEYS[1], 'updated_at', ARGV[1])
return 1

使用注意:

  • 键名拼接必须在 KEYS 之外完成(由调用方拼好后传入),脚本内不动态拼键名,否则集群模式无法定位槽。上例中的字符串拼接发生在服务端,仅适用于单机模式;集群模式下应把两个键都显式传入 KEYS 并保证同槽。
  • 幂等标记的 TTL 要与业务重试窗口匹配:过短会重复处理,过长会占用内存。
  • 脚本内先判断后写入,出错时已执行的写入不回滚,因此判断逻辑要放在所有写入之前。

3.4.3 脚本管理与版本化

  • 脚本文件放在应用资源目录(如 src/main/resources/lua/),随应用版本一起发布与评审,不在代码中内联大段脚本字符串。
  • 使用 EVALSHA 减少传输:客户端先 SCRIPT LOAD,之后按 SHA1 调用;捕获 NOSCRIPT 错误时重新加载并重试一次,不要无上限重试。
  • 客户端库通常提供脚本缓存能力(如 Spring Data Redis 的 DefaultRedisScript 会把脚本内容与 SHA1 一并发送,服务端优先按 SHA1 查找),无需自行处理缓存失效。
  • SCRIPT FLUSH 属 高危 操作:会清空服务端的全部脚本缓存,导致所有依赖 EVALSHA 的实例瞬时出现 NOSCRIPT 错误与重试放大。执行前确认业务客户端具备 NOSCRIPT 后的自动重载能力,并在低峰执行;回滚方式为让客户端重新加载脚本(多数客户端会自动完成),或在执行前导出脚本内容以便手工 SCRIPT LOAD。
  • Redis 7.0 起优先使用 FUNCTION LOAD ... REPLACE 与 FCALL:函数库会持久化到 RDB 与 AOF 并随复制传播,重启后无需重新加载,且支持按库名与函数名组织。需要跨实例一致性与持久性时,函数比 EVAL 更合适。
  • 慢脚本纳入排查:SLOWLOG 会记录脚本作为一条命令的耗时,脚本内的 redis.call 逐个计数在 COMMANDSTATS 中体现,据此定位脚本中耗时最高的调用。

3.4.4 事务的适用场景

需求 手段 理由
多条命令连续执行不被插入 MULTI/EXEC 执行期间不处理其他客户端命令
读后判断再写入,并发冲突少 WATCH 加 MULTI/EXEC 冲突时事务不执行,由应用侧重试
读后判断再写入,并发冲突多 Lua 脚本或函数 在服务端完成判断,避免重试风暴
单键计数与自增 INCR、HINCRBY 单命令原子,无需事务
失败需要撤销 无对应手段 Redis 事务不回滚,需在应用侧补偿或改用数据库事务

事务与脚本都要控制单次执行的操作规模:事务中的命令数量、脚本中的循环次数与访问的键规模,直接决定阻塞时长。

3.5 客户端使用要点

3.5.1 连接与超时

客户端库选择

维度 Lettuce Jedis
线程模型 基于 Netty 的异步客户端,连接线程安全,默认多线程共享一个连接 同步客户端,单个连接非线程安全,需配合连接池
连接开销 连接数量少,适合高并发共享 连接数量与并发线程数相关,池的配置直接影响性能
阻塞命令 使用独立连接执行阻塞类命令 从池中取连接,阻塞会占用池容量
异步与响应式 原生支持异步与响应式接口 以同步为主
Spring Boot 默认 是 需要显式引入 commons-pool2 并排除 Lettuce

选型结论:以 Spring Boot 为默认技术栈时使用 Lettuce;需要严格同步语义或已有连接池规范时使用 Jedis 并把池容量与实例数、线程数一起核算。

关键参数

spring:
  data:
    redis:
      host: 10.0.0.11
      port: 6379
      password: ${REDIS_PASSWORD}
      database: 0
      # 连接建立超时与命令读写超时
      connect-timeout: 2s
      timeout: 1s
      lettuce:
        pool:
          enabled: true
          # 最大连接数:按实例数与线程数核算,避免超过服务端 maxclients
          max-active: 16
          max-idle: 8
          min-idle: 2
          max-wait: 1s
  • 连接超时用于限制连接建立阶段的等待;命令超时用于限制单次命令的响应等待。二者都需要设置,不能只依赖默认值。
  • 命令超时后连接可能仍在执行,服务端的结果不可撤销。因此写命令的超时不能简单重试,需要按幂等性判断:SET、HSET 等幂等写可重试,INCR、LPUSH 等非幂等写重试会造成重复。
  • 连接数总量的上限受服务端 maxclients 约束(默认 10000),所有应用实例的连接数之和必须留有余量;只配连接池而不核算总量是连接被拒的常见原因。
  • 空闲连接应由池的健康检查与心跳维持,避免中间设备(防火墙、负载均衡、NAT)静默断开空闲连接后客户端仍认为连接可用(连接稳定性与超时设置见 linux: 网络诊断与远程连接)。

3.5.2 序列化

方式 体积 可读性 跨语言 适用
JDK 序列化 最大 差,二进制不可读 差,强依赖类结构 仅在完全同构且不在意体积时使用,不推荐
JSON 中等 好,可直接查看与调试 好 对象结构稳定、需要人工排查的场景
Protobuf、Kryo 等 小 差,需要 schema 或类结构 Protobuf 跨语言好,Kryo 依赖 Java 体积敏感、序列化耗时敏感的场景

约定要点:

  • 键统一使用字符串序列化(StringRedisSerializer),否则键名会带类型前缀的二进制字节,无法用命令行直接查看与运维。
  • 同一个键的值格式必须全局唯一。不同团队用不同序列化写同一个键,会造成部分读取失败且难以定位。
  • 序列化格式纳入文档与评审:新增缓存条目时明确 key 模式、value 结构、TTL 与格式版本。
  • 对象的字段增删要考虑兼容性:JSON 加字段通常兼容,删除或重命名字段需要评估在线实例的读取行为;无法保证时用键的版本号切换格式(见 3.1.1)。
  • 序列化本身有 CPU 成本,大对象的序列化耗时可能超过 Redis 访问本身;这种场景应压缩或减少传输的数据量(通用序列化取舍见 java: 序列化)。

3.5.3 Spring 生态的接入结构

依赖与配置

<!-- 默认使用 Lettuce;切换为 Jedis 需排除 lettuce 并引入相应依赖与连接池 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  • 配置前缀在 Spring Boot 2.x 为 spring.redis.*,3.x 迁移为 spring.data.redis.*,配置项含义不变;包含连接参数、超时、Lettuce 或 Jedis 的连接池与集群、哨兵配置。配置文件的组织方式见 Spring Boot 应用配置文件。
  • 集群模式的客户端配置使用 spring.data.redis.cluster.nodes 与 max-redirects;哨兵模式使用 spring.data.redis.sentinel.master 与 nodes,两种模式的差别见 Redis 高可用与集群 第 3.3 节。

组件结构

组件 职责 注意点
RedisConnectionFactory 连接管理与自动装配 集群与哨兵模式由配置决定实现
RedisTemplate 通用操作入口 必须显式配置四种序列化器,否则键为 JDK 序列化结果
StringRedisTemplate 键值均为字符串的模板 适合简单键值与配合 Lua 脚本使用
RedisCacheManager Spring Cache 注解的落地 TTL、序列化、空值策略统一配置,避免各缓存条目格式不一致
RedisMessageListenerContainer 订阅消息的容器 需要独立的监听器与执行器配置,订阅连接不应与业务连接争用
RedisScript 脚本执行 使用 DefaultRedisScript 加载脚本文件并指定返回类型
Redisson 等封装库 分布式锁、限流器、延迟队列等高级对象 引入后需核对与既有模板的序列化、连接配置是否一致
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 键与 hash 键使用字符串序列化,保证键名可读、可用命令行运维
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // 值使用 JSON 序列化,便于排查与跨语言读取
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                // 统一 TTL,并按缓存名覆盖
                .entryTtl(Duration.ofMinutes(30))
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(RedisSerializer.string()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()))
                // 不缓存空值,避免穿透数据长期占用内存;如使用空值防穿透需显式开启短 TTL
                .disableCachingNullValues();
        return RedisCacheManager.builder(factory).cacheDefaults(config).build();
    }
}

应用侧约定

  • 缓存注解(@Cacheable、@CacheEvict、@CachePut)的键表达式与 TTL 策略集中管理,不在各业务类中零散配置。
  • 分布式锁需设置锁的 TTL 与续期机制,并把业务处理的超时纳入设计;锁的失效不能依赖 Redis 的持久化(见 3.3.1 的组合建议)。
  • 应用指标至少覆盖:命令调用量、命令延迟分位值、超时与异常次数、连接池活跃连接数。Redis 侧指标见 linux: 监控与告警 与 消息中间件运维与治理 第 2.2 节的指标设计方法。
  • 健康检查:Actuator 的健康端点包含 Redis 连接状态,可作为实例就绪判断的一部分(见 Spring Boot 的 Actuator 部分);健康检查不应执行写命令或耗时命令。

上述组件的完整集成结构、序列化配置对照与数据库缓存一致性处理见 Redis 缓存实践与常见问题,一致性原理见 缓存基础与一致性;应用侧指标的采集与告警分级方法见 Redis 运维与监控。

3.5.4 客户端缓存(6.0 起)

  • RESP3 协议提供 CLIENT TRACKING:服务端记录客户端读取过的键,键发生变化时主动向该客户端发送失效消息,客户端据此清空本地缓存,从而减少读取往返。
  • 默认模式下失效消息可能丢失(连接断开期间的变更不会补发),需要正确性保证时使用广播模式或开启 OPTIN/OPTOUT 精细控制,代价是服务端需要维护更多的追踪状态。
  • 与自建本地缓存的差别:本地缓存不感知其他应用实例的写操作,需要额外的失效通道(如发布订阅)实现;客户端缓存把失效通知做到了协议层,但依赖客户端库支持。
  • 使用前评估服务端内存开销(追踪表的规模与键数量相关)与网络开销(失效消息量)。

3.6 版本特性与选型

3.6.1 版本能力差异

版本 关键能力
3.2 GEO 结构、quicklist 编码
4.0 模块系统、LFU 淘汰策略、UNLINK 与惰性释放、混合持久化、PSYNC2 部分重同步改进、MEMORY 命令族
5.0 stream 结构与消费组、主从复制与集群的稳定性改进
6.0 ACL 权限模型、TLS、多线程 IO、客户端缓存与 RESP3、无盘复制改进、STRALGO
6.2 COPY、GETDEL、GETEX;客户端缓存的广播模式改进
7.0 函数(FUNCTION/FCALL)、分片发布订阅(SSUBSCRIBE/SPUBLISH)、多文件 AOF、集群公告地址与端口、SINTERCARD、LMPOP/ZMPOP、maxmemory-clients、FLUSHALL ASYNC 等
7.2 WAITAOF(等待 AOF 刷盘确认)、小集合使用 listpack 编码、集群与复制的可观测性增强
7.4 hash 字段级过期时间(HEXPIRE 及其变体)

选型与升级注意:

  • 版本选择按需要的特性倒推:需要函数与分片发布订阅则至少 7.0;需要 hash 字段级 TTL 则至少 7.4;需要 WAITAOF 则至少 7.2。
  • 升级前核对不兼容变更与已废弃参数(例如编码相关参数在 7.0 中统一更名为 listpack 系列、部分旧命令别名被移除、模块 API 版本变化),并把回滚方案与降级限制一并确认:数据文件格式通常向前兼容但不向后兼容,跨大版本升级后回退需要同时回退数据文件。
  • 客户端与库的兼容性需要一并核对,尤其是 ACL 用户、RESP3、函数与分片发布订阅相关接口。
  • 升级的安全顺序、备份与验证项按 Redis 高可用与集群 第 3.5 节的备份流程执行。

3.6.2 单机与集群的命令差异

维度 单机(含主从、哨兵) Cluster
数据库编号 支持 0 到 15 的多个库,可用 SELECT 切换 仅支持 db0,SELECT 不可用
多键操作 无槽约束,任意键可组合 所有键必须落在同一槽,否则返回 CROSSSLOT
遍历键空间 KEYS、SCAN 覆盖整个实例 KEYS、SCAN 只覆盖当前节点;全集群遍历需逐节点执行
DBSIZE、FLUSHDB 作用于整个实例或当前库 只作用于当前节点(FLUSHDB 可加 ASYNC 降低阻塞)
事务与脚本 多键无槽限制 MULTI/EXEC 与脚本中的多键同样要求同槽,脚本的键必须通过 KEYS 传入
发布订阅 PUBLISH 直接向订阅者投递 7.0 之前广播到全集群;7.0 起可用分片发布订阅按槽分布
键空间通知 单一实例内全覆盖 事件只在键所在节点产生,订阅方需覆盖全部节点
槽未全覆盖时的行为 不涉及 由 cluster-require-full-coverage 决定是否仍对外提供服务
管理命令 DEBUG、MIGRATE、CLUSTER 等完整可用 部分命令行为受限或作用于本节点,跨节点操作由集群命令完成

涉及的主要跨槽受限命令包括:MGET、MSET、MSETNX、DEL(多键)、RENAME、SMOVE、SUNIONSTORE、SINTERSTORE、SDIFFSTORE、ZUNIONSTORE、ZINTERSTORE、BITOP、PFCOUNT(多键)、PFMERGE 等。

哈希标签的使用:键名中第一个 { 与第一个 } 之间的内容参与槽计算,因此 {user1000}.profile 与 {user1000}.sessions 落在同一槽,可参与同一次多键操作或事务。

  • 使用前提:这些键的业务访问模式确实是同时读写的,否则只是把跨槽问题换成数据倾斜问题。
  • 代价:同一标签的键必然落在同一节点,标签基数低时会造成负载倾斜;标签下的键会随槽一起迁移,迁移的数据量与耗时都上升。
  • 标签要有明确基数(例如按 1000 取模),避免所有键落在同一个标签而退化为单点。

3.6.3 选型结论

方案 容量 可用性 运维复杂度 适用
单机 受单机内存限制 进程或主机故障即不可用 低 开发测试、可容忍中断的内部工具
主从 读容量可扩展,写与内存仍受单节点限制 需要人工切换,切换期间写入中断 低 读多写少、可通过人工流程恢复
主从加哨兵 同上 自动故障转移,但仍可能丢失未同步写入 中 数据量与写入量在单节点可承受范围内、需要自动切换
Cluster 内存与写吞吐可水平扩展 自动故障转移,槽级隔离故障 高 数据量或写吞吐超过单节点上限
云托管实例 由实例规格决定,可弹性扩缩 由服务商保障,多数提供多可用区副本 低(但受服务商能力约束) 希望把故障转移与运维交给平台

托管方案的核对项:是否限制或禁用某些命令与参数、是否支持所需的持久化方式与副本数量、备份与恢复点能力的上限、版本跟进速度、是否能指定可用区部署、网络延迟与跨可用区流量成本、指标与日志的导出能力。这些约束会影响上表中的容量与可用性结论,选型时应以服务商的实际限制为准,而不是按自建 Redis 的能力推断。

集群方案的部署、迁移与故障处置见 Redis 高可用与集群。

四、总结

  • Redis 有两种角色:数据库前的缓存与分布式场景下的数据结构服务器。缓存允许淘汰与丢失,数据结构服务器需要持久化与副本,两者的配置取向相反,混用必须用 TTL 把两类键区分开。
  • 与磁盘数据库的取舍依据是延迟与成本的差别:Redis 承担高频读与需要原子语义的单键操作,全量存储、关联查询与严格事务留在数据库。
  • 命令由单线程串行执行。快的原因是数据在内存、无锁、编码紧凑、IO 多路复用;代价是任何慢命令都阻塞全局,因此命令与数据规模的约束优先于硬件规格。6.0 起把 socket 读写交给 IO 线程,命令执行仍在主线程。
  • 九种结构各有语义与复杂度。编码会按规模自动切换且单向不可逆,编码是判断内存异常与慢命令的第一指标;单键元素数量是容量与延迟规划的第一指标。
  • 过期由惰性删除与定期删除共同完成,删除时刻晚于 TTL 到期时刻,从节点等待主节点同步删除。淘汰策略有八种,选择依据是"数据能否重建"与"键是否设置 TTL",maxmemory 与策略必须成对配置。
  • 持久化的取舍是恢复速度与丢失窗口:RDB 恢复最快但丢失窗口最大,AOF everysec 兼顾两者,AOF always 丢失窗口最小但吞吐下降明显,混合持久化把快照前导与增量命令放在一起。
  • 事务保证命令不被穿插但不回滚,运行时错误只影响该条命令;WATCH 提供乐观锁,冲突多时应改用 Lua 脚本;脚本是原子的也是阻塞的,键必须通过 KEYS 传入,长度与规模必须有约束。
  • Pipeline 减少的是网络往返,不减少服务端执行量,也不提供原子性;需要原子语义时使用 Lua 脚本。
  • 发布订阅是发后即忘,只适用于允许丢失的通知场景;keyspace 通知可用于过期驱动与缓存失效,但事件在主线程产生、与 TTL 到期时刻不一致,不能作为唯一的一致性保证。
  • 内存由数据集、运行时开销、客户端与复制缓冲、持久化开销、碎片共同构成。maxmemory 的取值是可用内存减去这些预留项,容器限额必须大于 maxmemory 加预留量。
  • 落地层面的约束集中在四件事:键设计与大 key 热 key 治理、过期与淘汰的配置配对、持久化与恢复的验证流程、客户端连接与序列化的统一约定。
  • 破坏性操作(FLUSHALL 与 FLUSHDB、删除大 key、SCRIPT FLUSH、在线修改 maxmemory 与 dir)执行前必须确认影响范围与可用备份,并明确回滚方式;无备份时不得执行。