知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 02 - 持久化:RDB 与 AOF ## 为什么需要持久化 Redis 数据在内存中,宕机后数据丢失。持久化把内存数据写到磁盘,重启后可以恢复。 ## RDB(Redis Database) ### 原理 RDB 是某个时间点的内存快照,生成一个二进制文件(dump.rdb)。 触发方式: 1. 手动触发:SAVE(阻塞主进程)或 BGSAVE(fork 子进程后台执行,推荐) 2. 自动触发:配置 save 规则,如 `save 900 1`(900 秒内有 1 次写操作) 3. 主从复制时,主节点自动触发 BGSAVE 4. 执行 SHUTDOWN 命令时 BGSAVE 核心思路: - 主进程 fork() 一个子进程,由子进程完成快照写入 - 依靠操作系统的 COW(Copy-On-Write,写时复制)机制,fork 瞬间很快(只复制页表) - 子进程遍历内存写入 dump.rdb,主进程继续处理客户端请求 - 注意:若 fork 后主进程大量写入,会触发大量 COW,可能导致内存占用临时翻倍 > BGSAVE 的 fork + COW 深层原理、RDB 文件格式等详见:[BGSAVE 的 fork + COW 深层原理](#bgsave-的-fork--cow-深层原理) ### RDB 配置 ```bash # redis.conf save 900 1 # 900 秒内至少 1 次写操作,触发 BGSAVE save 300 10 # 300 秒内至少 10 次写操作 save 60 10000 # 60 秒内至少 10000 次写操作 dbfilename dump.rdb dir /var/lib/redis # 手动触发 BGSAVE # 后台生成快照 LASTSAVE # 查看上次 RDB 保存时间 ``` ### RDB 的优缺点 ``` 优点: 文件紧凑,体积小,适合备份和传输 恢复速度快(直接加载二进制文件) 对性能影响小(fork 后子进程处理) 缺点: 可能丢失最后一次快照后的数据(如每 5 分钟一次快照,最多丢 5 分钟数据) fork 时如果内存大,可能短暂阻塞(毫秒级) ``` ## AOF(Append Only File) ### 原理 ``` AOF 记录每条写命令,重启时重放所有命令来恢复数据。 写入流程: 客户端执行写命令 ↓ 命令追加到 AOF 缓冲区(aof_buf,内存中的 sds 字符串) ↓ 根据 fsync 策略写入磁盘 AOF 缓冲区的刷盘时机(两个阶段): 阶段 1:write 系统调用(写到 OS 的 Page Cache) 每次事件循环结束时,将 aof_buf 的内容 write 到 AOF 文件 write 返回后数据在 OS 缓冲区,还没到磁盘 阶段 2:fsync 系统调用(从 Page Cache 刷到磁盘) 由 appendfsync 参数控制频率 AOF 文件格式(RESP 协议文本): *3\r\n$3\r\nSET\r\n$4\r\nname\r\n$5\r\nhello\r\n *2\r\n$6\r\nEXPIRE\r\n$4\r\nname\r\n$4\r\n3600\r\n 可读性好,便于人工排查问题 但比 RDB 二进制格式体积大 ``` ### 三种 fsync 策略 ``` appendfsync always: 每条命令都 fsync 到磁盘 最安全(最多丢 1 条命令),但性能最差 appendfsync everysec(默认,推荐): 每秒 fsync 一次 最多丢 1 秒数据,性能和安全的平衡 appendfsync no: 由 OS 决定何时 fsync(通常 30 秒) 性能最好,但可能丢失较多数据 ``` ### AOF 重写(Rewrite)  *图:AOF 重写:由内存快照生成最小 AOF 并替换旧文件* ``` 问题:AOF 文件会越来越大(同一个 key 被修改 100 次,记录了 100 条命令) 解决:AOF 重写,用当前内存状态生成最小化的 AOF 文件 示例: 原 AOF: SET count 0 INCR count ← 执行了 100 次 INCR count ... (100 行) 重写后: SET count 100 ← 只需一行 重写过程(BGREWRITEAOF): ┌── 主进程 ──────────────────────────────────────┐ │ │ │ fork() ──→ 子进程 │ │ │ │ │ ├── 遍历内存,生成新 AOF 文件 │ │ │ (仅包含恢复数据所需的最小命令) │ │ │ │ │ └── 完成后通知主进程 │ │ │ │ 期间主进程继续处理客户端请求 │ │ 新写命令同时写入: │ │ ┌── 旧的 AOF 文件(持续追加) │ │ └── AOF 重写缓冲区(aof_rewrite_buf) │ │ │ │ 子进程完成后: │ │ 1. 将重写缓冲区内容追加到新 AOF 文件 │ │ 2. 用新 AOF 文件替换旧 AOF 文件 │ │ │ └─────────────────────────────────────────────────┘ 关键点: 重写不是分析旧 AOF 文件,而是读当前内存状态 所以 SET count 0 → INCR × 100 之后,重写只生成 SET count 100 fork 确保了子进程看到的内存是一致快照 ``` ```bash # redis.conf appendonly yes appendfilename "appendonly.aof" appendfsync everysec # 自动触发重写的条件 auto-aof-rewrite-percentage 100 # AOF 文件比上次重写后增长了 100% auto-aof-rewrite-min-size 64mb # AOF 文件至少 64MB 才触发 # 手动触发重写 BGREWRITEAOF ``` ### Redis 7.0 的 Multi-part AOF ``` Redis 7.0 之前,AOF 重写完成后会直接用一个新的 AOF 文件替换旧文件。 Redis 7.0 开始,引入了 Multi-part AOF,把 AOF 拆成多个部分管理。 核心文件通常有三类: 1. base.aof 由重写生成,记录某个时刻的"完整基线数据" 可以是 RDB preamble,也可以是 AOF 格式 2. incr.aof 记录 base 生成之后的新写命令(增量部分) 3. manifest 清单文件,记录当前哪些 base / incr 文件是有效的 Redis 启动恢复时,先读 manifest,再按顺序加载这些文件 ``` ``` 这样设计的好处: 1. 重写期间不需要频繁操作一个超大的单文件 2. 文件切换更清晰,失败恢复更稳妥 3. 启动恢复时可以明确知道该加载哪些文件 4. 更方便做 AOF 管理、切换和容错 ``` ``` 可以把它理解成: 老版本 AOF:一个大文件不断追加 + 重写替换 新版本 AOF:base 文件 + 增量文件 + manifest 清单 ``` ## RDB vs AOF 对比  *图:RDB 与 AOF 在安全性、体积、恢复速度等五个维度的对比* ``` 维度 RDB AOF ───────────────────────────────────────────────────────── 数据安全性 可能丢失几分钟数据 最多丢 1 秒(everysec) 文件大小 小(二进制压缩) 大(文本命令) 恢复速度 快 慢(需要重放命令) 性能影响 fork 时短暂影响 每秒 fsync 有轻微影响 适用场景 备份、容忍少量数据丢失 数据安全要求高 ```  ## 混合持久化(推荐,Redis 4.0+)  *图:混合持久化:aof 文件由 RDB 段与 AOF 段拼接而成* ``` 结合 RDB 和 AOF 的优点: AOF 文件的前半部分是 RDB 格式(快速加载) 后半部分是 AOF 格式(记录 RDB 之后的增量命令) 重启恢复流程: 1. 加载 AOF 文件前半部分(RDB 格式,速度快) 2. 重放后半部分(AOF 格式,增量命令少) 3. 恢复完成 混合持久化 AOF 文件结构: ┌──────────────────────────────────────────────────────────────┐ │ appendonly.aof │ │ │ │ ┌──────────────────────────┐ ┌───────────────────────────┐ │ │ │ RDB 段(二进制) │ │ AOF 段(文本) │ │ │ │ REDIS0009... │ │ *3\r\n$3\r\nSET\r\n... │ │ │ │ (内存快照,快速加载) │ │ (快照后的增量写命令) │ │ │ └──────────────────────────┘ └───────────────────────────┘ │ │ │ │ 每次重写后:重新生成一个新的 (RDB + 少量 AOF) 文件 │ └──────────────────────────────────────────────────────────────┘ 优点总结: 加载速度:RDB 段二进制加载快,不需要逐条重放命令 数据安全:AOF 段保证不丢数据,最多丢 1 秒 文件大小:比纯 AOF 小很多(RDB 二进制压缩) 配置: aof-use-rdb-preamble yes # 开启混合持久化(默认开启) ```  ## 数据恢复优先级 ``` Redis 启动时的恢复顺序: 1. 如果开启了 AOF → 优先用 AOF 恢复(数据更完整) 2. 如果只有 RDB → 用 RDB 恢复 3. 两者都没有 → 空数据库启动 ``` ## Redis 能完全保证数据不丢失吗 ``` 不能。 即使是 AOF 的 always 写回策略,也不能保证数据 100% 不丢失: 1. 磁盘和系统故障: 在写入操作和同步到磁盘之间发生硬件故障或系统崩溃 可能会丢失最近的写操作 2. 操作系统缓冲区: 即使 Redis 请求立即将数据同步到磁盘 操作系统的 I/O 缓冲区可能导致实际写入磁盘的操作延迟 如果在写入缓冲区之后、写磁盘前机器挂了,数据就丢了 3. Redis 基于内存存储: 虽然有 RDB 和 AOF 持久化机制 当 Redis 进程异常退出或服务器断电时 内存中的数据可能会丢失 ``` ## 面试常见问题 **Q:RDB 和 AOF 的区别?各自适用什么场景?** A:RDB 是内存快照,文件小、恢复快,但可能丢失几分钟数据,适合备份和容忍少量数据丢失的场景。AOF 记录每条写命令,最多丢 1 秒数据,但文件大、恢复慢,适合数据安全要求高的场景。生产环境推荐开启混合持久化,兼顾两者优点。 **Q:BGSAVE 的 fork + COW 机制是什么?** A:BGSAVE 时主进程 fork 出子进程,fork 只复制页表(很快),父子进程共享同一份内存。子进程遍历内存写 RDB 文件,父进程继续处理请求。当父进程修改某个内存页时,OS 才复制该页(COW),子进程始终看到 fork 时的快照。 **Q:AOF 重写的目的是什么?过程是怎样的?** A:AOF 文件会随时间增大(同一 key 多次修改会记录多条命令),重写用当前内存状态生成最小化的 AOF 文件。过程:fork 子进程遍历内存生成新 AOF,期间新写命令同时写入旧 AOF 和重写缓冲区,子进程完成后将缓冲区命令追加到新 AOF,最后替换旧文件。 ## BGSAVE 的 fork + COW 深层原理 ### COW(Copy-On-Write)详解 ``` 背景:Redis 持久化涉及把内存数据写入磁盘 如果在持久化时直接操作主进程,会阻塞所有请求 所以 Redis 单独开一个子进程去写文件,让主进程继续接受请求 操作系统的 fork: fork() 通过复制当前进程(父进程)创建一个新进程(子进程) 子进程获得父进程地址空间、堆栈、文件描述符等资源的副本 结果:fork() 产生一个和父进程完全相同的子进程(除了 PID) COW 核心思想: fork 后不会立即把原始数据完整拷贝一份 而是让新的"副本"和原始数据共享同一块内存区域 此时内存区域被操作系统标记为"只读" COW 的执行过程: 1. fork() 后,子进程的页表项指向与父进程相同的物理页 只需拷贝父进程的页表项,不用复制整个内存地址空间 同时把这些页表项标记为"只读" 2. 当父子进程都只读内存时,共享同一份物理页面 3. 只要父子进程有一个尝试修改某页面 CPU 硬件检测到内存页是 read-only,触发页异常中断(page-fault) 内核为该页面创建新的物理页面,复制内容到新页面 让父子进程各自拥有自己的物理内存页面,标记为"可写" 对应到 Redis: fork 后父子进程共享内存,子进程写 RDB/AOF 文件 主进程修改数据时触发 COW,只复制被修改的页 子进程始终看到 fork 时的内存快照 ``` ### BGSAVE 的完整执行流程  ``` 主进程 │ ├── fork() ──→ 子进程(复制主进程的页表,不复制实际数据) │ │ │ ├── 遍历内存,将数据写入 dump.rdb │ │ │ └── 写完后替换旧的 dump.rdb,退出 │ └── 继续处理客户端请求 好处:fork 很快(只复制页表,通常几毫秒),不阻塞主进程 坏处:如果 fork 后父进程大量写入,会触发大量 COW,内存占用翻倍 fork 的阻塞问题: fork 本身需要复制页表,内存越大耗时越长 16GB 内存的 Redis,fork 可能需要 100ms~1s 期间主进程阻塞,无法处理请求 → 生产环境要监控 latest_fork_usec(上次 fork 耗时) INFO stats | grep latest_fork_usec ``` ### RDB 文件格式  *图:RDB 文件整体结构,以及单个 key-value 的存储格式* ``` RDB 文件格式(二进制): ┌──────────┬──────────┬──────────────────────────────┬──────────┐ │ REDIS │ 版本号 │ 数据库数据(每个 db 一段) │ EOF+CRC │ │ (5字节) │ (4字节) │ db_number + key-value pairs │ 校验和 │ └──────────┴──────────┴──────────────────────────────┴──────────┘ 每个 key-value 的存储格式: ┌──────────┬──────────┬──────────┬──────────┐ │ 过期时间 │ 类型标识 │ key │ value │ │ (可选) │ (1字节) │ (SDS) │ (编码后) │ └──────────┴──────────┴──────────┴──────────┘ ``` --- 上一篇:[01 - 数据结构与底层实现](./01-data-structures.md) | 下一篇:[03 - 内存管理与淘汰策略](./03-memory-eviction.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入