深入了解Redis——持久化

一，Redis持久化

Redis持久化即将内存中的数据持久化到磁盘中，在下一次重启后还能进行使用，Redis持久化分为RDB和AOF两种，我们接下来分别介绍RDB和AOF的内部原理和区别

RDB

Redis运行时会将当前的内存快照存入至磁盘中，Redis重新启动后会将快照以二进制的形式给加载进入内存中，其中rdbSave和rdbLoad函数至关重要

什么时候会触发RDB？

• Redis停机时会触发
• 使用命令 save m n
• 主从同步执行全量复制
• debug reload命令重新加载Redis

保存

在RDB文件期间，主进程会被阻塞，直至保存完成，其中也分为了两种不同的保存方式SAVE和BGSAVE：

def SAVE():
 	rdbSave()
 
def BGSAVE():
     pid = fork()
     if pid == 0:
    	 # 子进程保存 RDB
     	rdbSave()
     elif pid > 0:
     	handle_request()
 	 else:
         # pid ==-1
         # 处理 fork 错误
        handle_fork_error()

• SAVE： 该方法会阻塞Redis主进程，此时不会响应用户请求，直至保存完成位置

​

• **BGSAVE：**该方法不会阻塞Redis主进程，主线程会查看是否已经fork了一个子线程，如果fork则返回，否则fork一个子进程采用CopyOnWrite机制将当前的快照存入磁盘中

​

SAVE，BGSAVE，BGREWRITEAOF能同时执行吗？

• 对于SAVE来说：

  由于SAVE是阻塞当前主进程的，所以此时此刻不管是用户命令还是BGSAVE和BGREWRITEAOF都无法执行，在执行SAVE指令前会检查BGSAVE是否在执行，如果在执行则不能进行SAVE

• 对于BGSAVE来说：

  **BGSAVE与BGSAVE：**通过上述代码我们可以知道，当BGSAVE正在执行时，会检查子进程是否fork如果fork了子进程则直接返回，所以是不能同时执行的

  **BGSAVE与BGREWRITEAOF：**BGSAVE正在执行时，BGREWRITEAOF会延迟收到指令直至BGSAVE执行完毕。如果BGREWRITEAOF正在执行，BGSAVE会直接返回报错，无法同时执行。

载入

Redis服务器启动时，就会进行rdbLoad函数，此时在载入期间每载入1000条数据就会处理一次当前的用户命令，当然这里的用户命令只能时订阅与发布功能相关的，其他的命令都会统一拒绝。

在载入的时候会优先选择AOF，如果没有设置AOF才会使用RDB

RDB文件结构

一个RDB的文件结构如下所示：

• **REDIS：**该字符标识着RDB文件的开始，相当于魔数
• RDB-VERSION（四字节）： 记录了当前文件RDB的版本号，读取的时候要使用对于版本号的方法读取
• DB-DATA： 该部分会在RDB文件中出现多次，保存着一个服务器上非空数据库的所有数据
• SELECT-DB： 代表着该键值对所属的数据库号码，读入RDB文件时，会根据该号码不断切换数据库
• KEY-VALUE-PAIRS： 代表着一个键值对的数据，每个键值对的数据会用以下结构来进行保存

​

OPTIONAL-EXPIRE-TIME： 这个代表着当前的键值对过期时间，如果没有则为null

TYPE-OF-VALUE： 代表着该键值对以什么样的类型进行存储，会根据不同的类型来进行VALUE的读取（这个地方内容较多，暂不介绍）

KEY： 存储着当前的键

VALUE： 存储着当前键保存的值

• EOF： 标志数据库内容的结尾，并不是文件的末尾
• CHECK-SUM： 文件内容校验和，读取时会对其进行文件内容的校验，如果为0则代表关闭了校验和功能

AOF

AOF以协议文本的方式，将所有对数据库写入的命令记录至AOF文件中，以此达到记录数据库状态的目的

AOF运行阶段

同步命令至AOF文件分为三个阶段：

① 命令传播： 将当前的Redis执行完的命令，以命令请求，命令参数，命令参数个数的形式传输给AOF程序

② 缓存追加： 将命令数据接收，并转换为网络通讯的协议方式，将内容追加至AOF缓存当中。

③ 文件写入和保存： 将缓存的内容根据设定的AOF条件写入至AOF文件末尾，此时会调用fsync函数或者fdatasync函数来将写入内容保存至磁盘中

此时会调用aof.c/flushAppendOnlyFile函数来执行以下两个工作：

WRITE（主进程阻塞）：根据写入条件，将当前aofBuf的内容写入至AOF文件末尾，这个是写入至文件缓冲区的，写入之后直接返回，如果此时发生宕机，此时写入的内容将丢失

SAVE（主进程看情况阻塞） ：根据保存条件，将当前的AOF文件缓存内容保存至磁盘中。采用fsync或fdatasync。

fysnc和fdatasync

参考文献

**fsync：**他会刷新文件的所有修改的核心数据包括文件关联的元数据，再刷新至磁盘中时，他会一直阻塞直至刷新完成

**fdatasync：**他和fsync类似，但是他不会刷新所有的文件元数据，会根据需要来进行刷新

AOF保存模式

Redis 目前支持三种 AOF 保存模式，它们分别是：

AOF_FSYNC_NO ：不保存

在不保存的情况下，整个Redis执行期间WRITE会被执行但是不会执行SAVE命令，只有以下几种可能会执行SAVE命令

• Redis被关闭
• AOF被关闭
• 系统的写缓存被刷

这三种情况下的SAVE都会导致主进程阻塞

AOF_FSYNC_EVERYSEC ：每一秒钟保存一次

SAVE在原则上会一秒钟执行一次，且这个SAVE是由fork出来的子进程进行执行的，但是值得注意的是这个是原则上面的一秒钟，它是否是每次一秒调用和当前Redis所处的状态有关。

• 子线程正在执行SAVE：

​ 如果执行SAVE时间小于2s：无需进行额外的write和save，程序执行返回

​ 如果执行SAVE时间超过2s：程序执行追加write，但不执行新的save。此时的write必须等待save执行完毕才能进行，所以主线程也会阻塞

• 子线程没有执行SAVE：

​ 如果上次执行SAVE距今不超过1s：程序执行write但不执行save

​ 如果上次执行SAVE时间距今超过1s：程序执行write和save

所以我们如果在上图的情况1宕机，那此时只会损失小于2s的数据，但是如果在情况发生宕机，此时write已经有2s没写入文件缓存并刷入磁盘，就会有2s的数据损失。所以说AOF_FSYNC_EVERTSEC只损失1s的数据是不准确的

AOF_FSYNC_ALWAYS ：每执行一个命令保存一次

每次执行完一个命令都会执行一次wirte指令和save指令，但是save是Redis主进程执行的所以主进程会阻塞

三种保存模式的对比图

AOF文件读取与数据还原

AOF文件内容如下

*2
 $6
 SELECT
 $1
 0
 *3
 $3
 SET
 $3
 key
 $5
 value
 *8
 $5
 RPUSH
 $4
 list
 $1
 1
 $1
 2
 $1
 3
 $1
 4
 $1
 5
 $1

我们可以看到在AOF文件内容中有一个SELECT 0 指令，该指令是为AOF文件指定要还原的数据库。

AOF文件的数据还原步骤如下：

① 开启一个伪客户端（fake cilent）

② 读取AOF的文件内容，并将其处理为命令，命令参数，参数个数该形式

③ 使伪客户端执行这些命令，直至所有命令执行完毕

这三步结束后，便会将AOF文件中的内容全部还原成数据库数据。在加载和还原期间只有订阅和发布功能能够使用，其他的都不能使用。

def READ_AND_LOAD_AOF():
 	# 打开并读取 AOF 文件
    file = open(aof_file_name)
 	while file.is_not_reach_eof():
         # 读入一条协议文本格式的 Redis 命令
        cmd_in_text = file.read_next_command_in_protocol_format()
         # 根据文本命令，查找命令函数，并创建参数和参数个数等对象
        cmd, argv, argc = text_to_command(cmd_in_text)
 		# 执行命令
		execRedisCommand(cmd, argv, argc)
 	# 关闭文件
	file.close()

AOF重写

对于一个Redis服务器来说，可能会接收几十万上千万的指令请求，如果此时将这些请求全部存入AOF文件，将会导致AOF文件不断庞大，对Redis和系统造成影响，于是为了将AOF文件进行压缩，便设计了AOF重写方法：AOF文件并不一定要写入所有的客户端指令只要保证前后状态一致即可，创建一个新的AOF文件替代原本的AOF文件，新AOF文件和原有的AOF文件对于数据库状态完全一样

实现原理：

对于下列命令集合我们可以发现，我们一开始创建了一个list[1,2,3,4]，然后经过三次操作将其变为了list[1,2,3]，那其实这四段命令我们可以直接压缩成一行也就是RPUSH list 1 2 3，这样即使的结果和前面的四次操作完全一致。

RPUSH list 1 2 3 4	 // [1, 2, 3, 4]
RPOP list			// [1, 2, 3]
LPOP list			// [2, 3]
LPUSH list 1		// [1, 2, 3]

def AOF_REWRITE(tmp_tile_name):
 	f = create(tmp_tile_name)
 	# 遍历所有数据库
    for db in redisServer.db:
         # 如果数据库为空，那么跳过这个数据库
        if db.is_empty(): continue
         # 写入 SELECT 命令，用于切换数据库
        f.write_command("SELECT " + db.number)
     	# 遍历所有键
        for key in db:
     		# 如果键带有过期时间，并且已经过期，那么跳过这个键
            if key.have_expire_time() and key.is_expired(): continue
    	    if key.type == String:
         		# 用 SET key value 命令来保存字符串键
    			value = get_value_from_string(key)
     			f.write_command("SET " + key + value)
     		elif key.type == List:
                 # 用 RPUSH key item1 item2 ... itemN 命令来保存列表键
                 item1, item2, ..., itemN = get_item_from_list(key)
     			f.write_command("RPUSH " + key + item1 + item2 + ... + itemN)
     		elif key.type == Set:
                 # 用 SADD key member1 member2 ... memberN 命令来保存集合键
                member1, member2, ..., memberN = get_member_from_set(key)
                f.write_command("SADD " + key + member1 + member2 + ... + memberN)
     		elif key.type == Hash:
                 # 用 HMSET key field1 value1 field2 value2 ... fieldN valueN 命令来保存哈希键
                field1, value1, field2, value2, ..., fieldN, valueN =\
                get_field_and_value_from_hash(key)
                f.write_command("HMSET " + key + field1 + value1 + field2 + value2 +\
                ... + fieldN + valueN)
     		elif key.type == SortedSet:
                 # 用 ZADD key score1 member1 score2 member2 ... scoreN memberN
                 # 命令来保存有序集键
                 score1, member1, score2, member2, ..., scoreN, memberN = \
                 get_score_and_member_from_sorted_set(key)
                 f.write_command("ZADD " + key + score1 + member1 + score2 + member2 +\
                 ... + scoreN + memberN)
             else:
                 raise_type_error()
                 # 如果键带有过期时间，那么用 EXPIREAT key time 命令来保存键的过期时间
    		if key.have_expire_time():
     			f.write_command("EXPIREAT " + key + key.expire_time_in_unix_timestamp())
         # 关闭文件
        f.close()

从上面的代码我们可以总结出以下步骤：

• 遍历数据库，如果数据库为空则跳过，否则进入进行key遍历
• 对所有的key进行遍历，如果key过期了则跳过，否则直接根据类型获取key的值，然后通过set的方式将其写入AOF文件中
• 如果key有过期时间则给其赋予过期时间
• 关闭文件写入

后台AOF重写

通过上面的AOF重写我们可以得知AOF重写是阻塞的，Redis也为AOF重写fork了一个子进程进行重写的处理。

① 执行BGREWRITEAOF指令，父进程fork出一个子进程来进行AOF重写操作

② 同时创建aof_rewrite_buf来缓存在重写过程中，执行的新的命令，父进程会将执行的命令同时放入aof_rewrite_buf和aof_buf中，保证不管是重写失败还是重写过程中都不会发生丢失数据的情况。

③ 子进程根据aof_rewrite_buf将重写后的指令写入新的AOF文件中

④ 当前重写全部执行完成后向父进程发送一个通知

⑤ 父进程将新的AOF文件与旧的AOF文件替换，完成重写

重写的自动触发条件：

重写可以通过手动命令bgrewriteaof进行，也可以自动进行不过要符合以下条件

• 没有BGSAVE在执行
• 没有SAVE在执行
• 没有BGREWRITEAOF在执行
• 当前AOF文件大小大于aof_rewrite_min_size(重写触发最小值 默认1mb)
• 比较当前AOF文件和最后一次AOF文件重写的大小之间的比例是否超过一倍（比如当前AOF文件是2MB，重写时的文件是1MB，此时就超过一倍了）

符合以上条件则会进行自动的AOF重写。