第一次看到 Redis 的压测结果,我也怀疑过。在 8 核机器上跑 redis-benchmark -t set,get -n 100000 -c 50 -q,输出大概是 SET 十万零八千次每秒、GET 十一万两千次每秒。同事的第一反应是:「Redis 不是单线程吗,单线程怎么可能比多线程的 MySQL 快三个数量级,压测脚本肯定写错了。」

这个疑问里混了两件事:单线程到底指哪一段单线程,以及十万 QPS 到底高在哪。把这两件事分开看,数字就不神秘了。这篇先补齐数字的语境,再拆开「快」的四个来源,然后说清楚持久化到底能保住多少数据,最后用一次「重启后回退一秒」的排查收尾。

文中所有命令输出和基准数字都没有在本机实测,本机没有安装 Redis。数字是按 Redis 7.x 在常见云主机上的量级写的,用来建立直觉,不是给你当容量规划依据。你要的准确值得在自己的机器上跑。

先把数字的语境补齐

十万 QPS 大约是每个请求十微秒。一次内存访问是百纳秒级,一次本机回环的网络往返是几十微秒,一次 SSD 随机读是一百微秒级。也就是说,一条简单的 GET 里,真正花在「查数据」上的时间很少,大部分时间在网络上。这解释了为什么单线程够用:它不是在算,是在等。

还要看清 benchmark 测的是什么。它测的是一个很小的 value、固定的 key、客户端五十个并发、没有 pipeline,网络是本机回环。真实业务里 value 更大、命令更复杂、客户端和服务之间隔着交换机,还要加上序列化和反序列化,QPS 往往只有几千到几万。把 benchmark 数字直接写进容量方案,是新人最常犯的错。

看实例的真实负载,用 INFO stats 和 INFO cpu,而不是猜:

INFO stats
# Stats
total_connections_received:184203
total_commands_processed:98213440
instantaneous_ops_per_sec:84211
keyspace_hits:91230012
keyspace_misses:2043118
evicted_keys:0

INFO cpu
used_cpu_sys:1820.44
used_cpu_user:2911.07

instantaneous_ops_per_sec 是最近一秒处理的命令数,不是业务请求数,一个业务请求可能对应五条命令。命中率用 keyspace_hits 除以两者之和算,命中率突然掉下去,先查是缓存被淘汰还是业务在查不存在的 key。CPU 那两个数是累计值,要连续采样两次做差,才能看出主线程用了多少。

为什么快:四件事叠在一起

「快」不是一个原因造成的,是四个互相配合的选择。缺一个,数字都到不了这个量级。

纯内存:读写不碰磁盘数据在 RAM 里,一次访问百纳秒级,磁盘随机读是百微秒级,差三个数量级。持久化是旁路:RDB 由子进程做,AOF 由后台线程刷盘,正常情况下不在命令的执行路径上。只有 appendfsync always 例外,那条命令要等落盘。
单线程执行命令:没有锁和上下文切换所有命令在一个主线程里串行执行,不需要为共享数据结构加锁,也没有线程切换的开销。一次线程切换要一到两微秒,在高并发下锁竞争更贵;这些成本在 Redis 里直接不存在。
IO 多路复用:一个线程管几千个连接用 epoll 监听所有 socket,哪个连接来了数据就处理哪个,不用为每个连接开一个线程。省掉了几千个线程的栈内存和调度成本,也避免了「线程都在等网络」的浪费。
命令本身复杂度低GET 和 SET 是 O(1),ZADD 和 ZSCORE 是 O(log N),LRANGE 取一段是 O(log N + M)。绝大多数命令在微秒级完成,不会有「一条命令算一秒」的情况。

这四件事里,最容易误解的是第二条。单线程不是「只有一个线程在干活」,而是「执行命令这件事只有一个线程在做」。网络读写、持久化、异步删除都有别的线程或进程参与。

「单线程」到底指什么

准确说法是:命令的执行是单线程的。从 socket 读到一条完整命令,解析参数,查字典,执行,把回复写回去,这一整串在一个主线程里串行完成。这也是为什么一条慢命令会阻塞所有客户端。

Redis 6.0 引入了 IO 多线程,但只分担网络读写:多个线程可以从 socket 并行读请求、解析协议,也可以并行把回复写出去,命令真正执行时仍然回到主线程。默认 io-threads 1,也就是没开;要开就配成 4 或 8,并且只在网络确实是瓶颈时才有收益。

除此之外还有后台角色:做 RDB 和 AOF 重写的子进程(fork 出来的),做 fsync 和关闭文件的后台线程,做大 key 异步删除的线程。它们都不执行命令,所以不破坏「命令串行」这个前提。

为什么命令执行不改成多线程?因为共享数据结构要加锁。多个线程同时改一个哈希表,锁的粒度和竞争会把多核收益吃掉,还会引入大量同步逻辑。而 Redis 的定位是低延迟、简单可靠,不是把多核吃满。要吃多核,正确的做法是开多个实例或者上集群,让每个实例各自单线程。

代价也很直接:一条 KEYS * 在千万级 key 上可能跑几百毫秒,这几百毫秒里所有请求排队;一次百万元素的集合求交、一次大 key 的 DEL,效果一样。单线程把「并发安全」换成了「对慢命令零容忍」。

数据结构与编码:快在细节里

命令快,除了内存和单线程,还因为底层实现针对场景做了取舍。挑五个最关键的看。

SDS。Redis 的字符串不是 C 字符串,是带头的 SDS。头部记录了长度和已分配空间,所以 STRLEN 是 O(1),而 C 字符串要遍历;它允许值里出现 \0,所以是二进制安全的;追加时按「小于 1MB 就翻倍,大于 1MB 每次加 1MB」预分配,减少反复申请内存;缩短时不立刻归还,避免频繁释放。这解释了为什么 APPEND 和 SETRANGE 在长字符串上也不慢。

dict 的渐进式 rehash。哈希表扩容时不是一次性把几十万个 key 搬完,而是保留两张表,每次操作顺手搬一个桶,直到搬完。这样把一个 O(N) 的停顿摊成了很多个 O(1),几十万 key 的实例扩容时也不会卡住。代价是扩容期间内存要同时放两张表,查询也要先查旧表再查新表。

listpack 和 intset。元素少的时候,List、Hash、ZSet 用 listpack 存:一整块连续内存,每个元素记录自己的长度,从头尾都能走,省掉了指针和对象头,缓存也友好。Set 如果全是整数且数量不多,用 intset:一个有序数组加二分查找,内存占用极低。这些紧凑编码是「小对象省内存」的关键。

跳表。ZSet 元素变多之后,转成「字典加跳表」。字典负责成员到分数的 O(1) 查询,跳表负责按分数有序遍历,插入删除 O(log N),范围查询 O(log N + M)。为什么不用红黑树?跳表实现简单,范围查询顺着底层链表走,对缓存友好,也不用旋转。这是一次典型的工程取舍,不是算法上的最优。

这些编码会随元素数量和单个元素大小切换。用 OBJECT ENCODING 和 MEMORY USAGE 能看到当前用的是哪种:

OBJECT ENCODING user:1001
"listpack"
OBJECT ENCODING post:1001:likers
"intset"
OBJECT ENCODING hot:20261106
"listpack"
MEMORY USAGE hot:20261106
(integer) 2464

编码切换的阈值在配置文件里,常见的默认值是 128 个元素、单个值 64 字节,具体随版本不同,待确认,用 CONFIG GET *-max-listpack-entries 查当前值。这件事的实际意义是:同样一条命令,在测试环境的一百个元素和生产环境的十万个元素上,耗时可能差两个数量级。压测必须用生产量级的数据。

持久化:RDB 丢什么,AOF 丢什么

Redis 是内存数据库,重启就要把数据从文件里读回来。两种文件格式,各有各的丢数据窗口。

RDB 是快照。把某一时刻的全量数据序列化成二进制文件。触发方式有:SAVE 在主线程做,会阻塞,线上别用;BGSAVE fork 一个子进程做;配置文件里的定时规则,比如 3600 秒内有 1 次写、300 秒内有 100 次写、60 秒内有 1 万次写(默认值随版本有调整,以 CONFIG GET save 为准);正常关闭时也会存一次。

fork 加写时复制(COW)是关键。fork 出来的子进程和父进程共享同一批内存页,父进程不改的时候一页都不复制;父进程每写一页,操作系统就把那一页复制一份给子进程。所以 fork 瞬间几乎不占额外内存,但写入越多,复制的页越多,最坏情况下内存接近翻倍。一个 20GB、写入很猛的实例做 BGSAVE,要预留三十多 GB 才安全。

fork 本身还会阻塞主线程,阻塞时长和内存页表大小相关,几个 GB 的实例常见几十毫秒,具体要看 INFO persistence 里的 latest_fork_usec。所以「RDB 丢什么」的答案是:丢最后一次快照之后的所有写。按 60 秒 1 万次写的规则,最坏丢一分钟;如果一天只手动存一次,最坏丢一天。

AOF 是命令日志。每条写命令追加到文件末尾,重启时从头重放。丢多少取决于刷盘策略,配置项是 appendfsync:

策略什么时候真正写到磁盘最坏丢多少代价
always每条写命令都 fsync基本不丢,只剩磁盘缓存撒谎的极小窗口QPS 掉得厉害,一次 fsync 是毫秒级
everysec每秒由后台线程 fsync 一次最多一秒内的写默认值,性能和安全的折中
no交给操作系统决定通常几十秒,最坏不可控最快,但不敢用来兜账

AOF 文件会越来越大,所以需要重写。BGREWRITEAOF 同样 fork 子进程,把当前内存里的数据写成「最小命令集」:比如同一个 key 被 INCR 了一百次,重写成一条 SET。重写期间的新写入先记在缓冲区,完成后追加到新文件。

Redis 4.0 之后支持混合持久化,配置 aof-use-rdb-preamble yes,AOF 文件的前半段是 RDB 格式的快照,后半段是增量命令。重启时先加载快照再重放少量命令,恢复速度快很多。这是现在多数生产实例的默认选择。

把结论说死一点:RDB 丢「最后一次快照之后的全部写入」;AOF everysec 丢「最后一秒」;AOF always 基本不丢。所以「开了持久化就不会丢数据」这句话是错的,要看开的是哪种、配的哪个策略。

持久化文件不是备份。误删一个 key 会被写进 AOF,跟着重放;主从复制会把误删同步到从库;文件本身也可能损坏。备份要定时把 RDB 或 AOF 拷到另一台机器,并且定期真的恢复一次,确认文件能用。

一次完整的场景走查:重启后数据回退一秒

周一早上发版,重启了一个缓存实例。业务方过来说:重启前刚写进去的一批计数丢了,时间窗大概一秒,怀疑 Redis 把数据吞了。这不是玄学,按顺序查五步就能定性。

第一步,确认持久化模式和刷盘策略。

CONFIG GET appendonly
1) "appendonly"
2) "yes"
CONFIG GET appendfsync
1) "appendfsync"
2) "everysec"

AOF 开着,策略是每秒刷一次。到这里其实已经有答案了:everysec 的设计就是最多丢一秒,这是写在文档里的正常行为,不是故障。

第二步,确认持久化本身是健康的。

INFO persistence
# Persistence
loading:0
rdb_changes_since_last_save:1842
rdb_bgsave_in_progress:0
rdb_last_save_time:1762305120
rdb_last_bgsave_status:ok
aof_enabled:1
aof_rewrite_in_progress:0
aof_last_bgrewrite_status:ok
aof_last_write_status:ok
latest_fork_usec:18240

aof_last_write_status 和 aof_last_bgrewrite_status 都是 ok,说明文件没写坏;latest_fork_usec 是 18 毫秒,属于正常范围。如果这里是 err,问题就变成「磁盘满了或权限错了」,那是另一条排查线。

第三步,确认不是主从切换造成的。重启时如果发生过主从切换,从库可能落后于主库,丢的数据就不止一秒。INFO replication 里看 master_link_status 和两个节点的 master_repl_offset 差多少,差得大说明复制有延迟。

第四步,把时间线摆出来。客户端在 T 时刻写成功,Redis 返回 OK;后台线程在 T 加 0.9 秒时 fsync;进程在 T 加 0.95 秒时重启。这条写在内存里、还没落盘,就丢了。窗口长度取决于 fsync 的节奏,最长一秒。

第五步,决定要不要改。如果业务不能接受一秒,有三条路:改成 appendfsync always,代价是 QPS 从十万掉到几千到一万量级,具体看磁盘,这是推演不是实测;或者在应用层把计数异步落库,重启后从库里重建;或者换一种对丢失不敏感的存储。我们最后选了第二条,因为计数本来就可以从明细表重算。

结果与代价:结论是「没有吞数据,是一秒的正常窗口」。方案改成计数异步落库加启动时重建,接受秒级丢失,换取写入性能不变。多了一条补偿链路和一份对账任务,这是这次排查真正的产出。

排查丢数据,先问三个问题:开的 RDB 还是 AOF,刷盘策略是什么,重启前有没有主从切换。三个答案齐了,基本就能算出最坏丢多少,不用猜。

现象、原因与第一步排查

下面这些现象,多半不是「Redis 有 bug」,而是内存、单线程和持久化这三件事的必然结果。

现象真实原因第一步查什么
每隔一段时间出现几十毫秒的延迟尖刺BGSAVE 或 AOF 重写 fork 子进程,阻塞主线程INFO persistence 看 latest_fork_usec 和 rdb_last_save_time,对齐尖刺时间
内存突然接近翻倍写时复制,BGSAVE 期间父进程写入的页被逐页复制看是否有 rdb_bgsave_in_progress,对比 used_memory 和 used_memory_rss
重启后丢了一段数据AOF everysec 的一秒窗口,或没开 AOF 只靠 RDB 定时快照CONFIG GET appendonly 和 appendfsync,再看 CONFIG GET save
主从数据对不上复制延迟、从库被写、淘汰策略导致主从淘汰不同步INFO replication 看两个节点的 offset 差和 master_last_io_seconds_ago
写入报 OOM 错误达到 maxmemory 且策略是 noeviction,或没有可淘汰的 keyCONFIG GET maxmemory 和 maxmemory-policy,看 evicted_keys
一条命令让整个实例卡住KEYS、大 key 的 DEL、大集合运算都在主线程执行SLOWLOG GET 10 找慢命令,LATENCY DOCTOR 看延迟事件
淘汰开始后命中率骤降近似 LRU 加批量淘汰,热点 key 被一起赶出去看 evicted_keys 增速和 keyspace_hits 与 keyspace_misses 的比例

边界与代价

第一,fork 会阻塞。实例越大、页表越大,阻塞越久;写越猛,COW 复制的页越多,内存峰值越高。把实例控制在十 GB 以内、留足内存余量,比事后调参有用。

第二,大 key 是单线程的天敌。删一个百万元素的 Set,主线程要一个个释放,几百毫秒就过去了,用 UNLINK 让后台线程删。KEYS 换成 SCAN,大 Hash 的 HGETALL 换成 HSCAN,大集合的交并差换成带 LIMIT 的版本。

第三,swap 会让一切归零。内存被换到磁盘,延迟从微秒变成毫秒,Redis 会慢到不可用。生产机器要关 swap,或者把 vm.swappiness 调到 1,并监控 used_memory_rss 是否超过物理内存。

第四,内存碎片是慢性病。频繁增删不同大小的对象会让碎片率上升,mem_fragmentation_ratio 长期高于 1.5 就要处理:开 activedefrag,或者挑个低峰重启。碎片不会自己消失。

第五,持久化文件不能当备份。前面说过,误删会同步、文件会损坏。要有异地备份,要定期恢复演练,要知道你的 RTO 和 RPO 分别是多少。

第六,单线程不吃多核,这是架构选择不是缺陷。垂直扩展靠加内存,水平扩展靠多实例或集群,代价是客户端要处理分片、多 key 操作受限、运维复杂度上升。如果你的场景需要复杂查询、二级索引、强事务,那不是调 Redis 能解决的,应该换存储。

所以「Redis 快」是有条件的:数据放得下内存,命令都是 O(1) 或 O(log N),没有大 key,没有 swap,持久化策略匹配业务对丢失的容忍度。任何一条不成立,快就会变成「偶发但致命」的慢。

当天可以自己验证的练习

  1. 起一个本地实例,连续两次执行 INFO memory,记录 used_memory、used_memory_rss、mem_fragmentation_ratio,写入一批不同大小的 key 后再看这三个数的变化。
  2. 执行 CONFIG SET slowlog-log-slower-than 1000,然后跑一条 KEYS *,用 SLOWLOG GET 10 确认它进了慢日志,并看耗时。
  3. 用 redis-cli --latency -h 127.0.0.1 -p 6379 观察延迟分布,按 Ctrl+C 停止;同时在另一个终端做一次 BGSAVE,看尖刺有没有对应上。
  4. 把 maxmemory 设成几十兆,策略设成 allkeys-lru,持续写入直到开始淘汰,用 INFO stats 看 evicted_keys,再用 CONFIG GET maxmemory-policy 确认配置生效。
  5. 分别用 appendfsync everysec 和 always 跑 redis-benchmark -t set -n 10000 -q,比较两组 QPS,亲手感受一次 fsync 的代价。

小结

Redis 快,是因为纯内存、命令单线程、IO 多路复用和低复杂度命令叠在一起,不是因为某个魔法开关。单线程指的是命令执行,网络读写和持久化都有别的角色参与。理解这一点,才能理解为什么一条慢命令能拖垮整个实例。

持久化要分两层看:RDB 丢最后一次快照之后的全部写入,AOF 按 everysec 最多丢一秒,always 基本不丢但很慢。所谓「开了持久化就安全」是错觉,真正决定你丢多少的是配置和业务容忍度。

下一篇讲文档数据库上手:从 EAV 的痛苦到内嵌文档。Redis 的模型是「key 加固定的几种结构」,它不关心里面是什么;当你存的是会不断加字段的商品、订单、内容,每次改结构都要在应用层做迁移,文档库把字段放进数据库本身就更顺手。