13.AOF日志

★4.AOF日志

如果有人问你："你会把 Redis 用在什么业务场景下？"

我想你大概率会说："我会把它当作缓存使用，因为它把后端数据库中的数据存储在内存中，然后直接从内存中读取数据，响应速度会非常快。"

没错，这确实是 Redis 的一个普遍使用场景，但是，这里也有一个绝对不能忽略的问题：一旦服务器宕机，内存中的数据将全部丢失。

我们很容易想到的一个解决方案是，从后端数据库恢复这些数据，但这种方式存在两个问题.

一是，需要频繁访问数据库，会给数据库带来巨大的压力；

二是，这些数据是从慢速数据库中读取出来的，性能肯定比不上从 Redis 中读取，导致使用这些数据的应用程序响应变慢。

所以，对 Redis 来说，实现数据的持久化，避免从后端数据库中进行恢复，是至关重要的。目前，Redis 的持久化主要有两大机制，即 AOF（Append Only File）日志和 RDB 快照。在接下来的两节课里，我们就分别学习一下吧。这节课，我们先重点学习下 AOF 日志。

AOF 日志是如何实现的？

★写后日志:先命令再日志,和WAL相反

说到日志，我们比较熟悉的是数据库的写前日志（Write Ahead Log, WAL），也就是说，在实际写数据前，先把修改的数据记到日志文件中，以便故障时进行恢复。

不过，AOF 日志正好相反，它是写后日志，"写后"的意思是 Redis 是先执行命令，把数据写入内存，然后才记录日志，如下图所示：

那 AOF 为什么要先执行命令再记日志呢？要回答这个问题，我们要先知道 AOF 里记录了什么内容。

AOF日志内容:命令

传统数据库的日志，例如 redo log（重做日志），记录的是修改后的数据。

而 AOF 里记录的是 Redis 收到的每一条命令，这些命令是以文本形式保存的。

我们以 Redis 收到"set testkey testvalue"命令后记录的日志为例，看看 AOF 日志的内容。

"*3"表示命令有三部分,每部分由["$+数字"开头，后面紧跟着具体的命令、键或值]。

"数字"表示这部分中的命令、键或值一共有多少字节。

例如，"$3 set"表示这部分有 3 个字节，也就是"set"命令。

好处:命令执行成功再记日志,避免记录错误命令

但是，为了避免额外的检查开销，Redis 在向 AOF 里面记录日志的时候，并不会先去对这些命令进行语法检查。

所以，如果先记日志再执行命令的话，日志中就有可能记录了错误的命令，Redis 在使用日志恢复数据时，就可能会出错。

而写后日志这种方式，就是先让系统执行命令，只有命令能执行成功，才会被记录到日志中，否则，系统就会直接向客户端报错。所以，Redis 使用写后日志这一方式的一大好处是，可以避免出现记录错误命令的情况。

除此之外，AOF 还有一个好处：它是在命令执行后才记录日志，所以不会阻塞当前的写操作。

风险1:写后日志可能会丢失

不过，AOF 也有两个潜在的风险。

首先，如果刚执行完一个命令，还没有来得及记日志就宕机了，那么这个命令和相应的数据就有丢失的风险。 如果此时 Redis 是用作缓存，还可以从后端数据库重新读入数据进行恢复，但是，如果 Redis 是直接用作数据库的话，此时，因为命令没有记入日志，所以就无法用日志进行恢复了。

所幸我们一般情况下不会将Redis作为数据库使用。

风险2:写后日志会阻塞下一个操作

其次，AOF 虽然避免了对当前命令的阻塞，但可能会给下一个操作带来阻塞风险。这是因为，AOF 日志也是在主线程中执行的，如果在把日志文件写入磁盘时，磁盘写压力大，就会导致写盘很慢，进而导致后续的操作也无法执行了。

仔细分析的话，你就会发现，这两个风险都是和 AOF 写回磁盘的时机相关的。这也就意味着，如果我们能够控制一个写命令执行完后 AOF 日志写回磁盘的时机，这两个风险就解除了。

★写回策略:Always、Everysec、No

其实，对于这个问题，AOF 机制给我们提供了三个选择，也就是 AOF 配置项 appendfsync 的三个可选值。

Always，同步写回：每个写命令执行完，立马同步地将日志写回磁盘；
​
Everysec，每秒写回：每个写命令执行完，只是先把日志写到 AOF 文件的内存缓冲区，每隔一秒把缓冲区中的内容写入磁盘；
​
No，操作系统控制的写回：每个写命令执行完，只是先把日志写到 AOF 文件的内存缓冲区，由操作系统决定何时将缓冲区内容写回磁盘。

针对避免主线程阻塞和减少数据丢失问题，这三种写回策略都无法做到两全其美。我们来分析下其中的原因。

★Always同步写回

主线程性能差,可以保证不丢数据

★Everysec每秒写回

性能折中,可能丢失2秒数据:上一秒的数据还未落盘,下一秒的数据也未落盘

 同步写回"可以做到基本不丢数据，但是它在每一个写命令后都有一个慢速的落盘操作，不可避免地会影响主线程性能；
​
 虽然"操作系统控制的写回"在写完缓冲区后，就可以继续执行后续的命令，但是落盘的时机已经不在 Redis 手中了，只要 AOF 记录没有写回磁盘，一旦宕机对应的数据就丢失了。
​
 "每秒写回"采用一秒写回一次的频率，避免了"同步写回"的性能开销，虽然减少了对系统性能的影响，但是如果发生宕机，上一秒内未落盘的命令操作仍然会丢失。所以，这只能算是，在避免影响主线程性能和避免数据丢失两者间取了个折中。

★No操作系统控制写回

性能好,丢失数据较多

我把这三种策略的写回时机，以及优缺点汇总在了一张表格里，以方便你随时查看。

到这里，我们就可以根据系统对高性能和高可靠性的要求，来选择使用哪种写回策略了。

总结一下就是：想要获得高性能，就选择 No 策略；如果想要得到高可靠性保证，就选择 Always 策略；

如果允许数据有一点丢失，又希望性能别受太大影响的话，那么就选择 Everysec 策略。

★AOF日志文件过大

但是，按照系统的性能需求选定了写回策略，并不是"高枕无忧"了。毕竟，AOF 是以文件的形式在记录接收到的所有写命令。随着接收的写命令越来越多，AOF 文件会越来越大。这也就意味着，我们一定要小心 AOF 文件过大带来的性能问题。

这里的"性能问题"，主要在于以下三个方面：

★文件大小有限制

一是，文件系统本身对文件大小有限制，无法保存过大的文件；

★追加效率变差

二是，如果文件太大，之后再往里面追加命令记录的话，效率也会变低；

★宕机恢复过慢

三是，如果发生宕机，AOF 中记录的命令要一个个被重新执行，用于故障恢复，如果日志文件太大，整个恢复过程就会非常缓慢，这就会影响到 Redis 的正常使用。所以，我们就要采取一定的控制手段，这个时候，AOF 重写机制就登场了。

解决日志文件过大:AOF重写机制

简单来说，AOF 重写机制就是在重写时，Redis 根据数据库的现状创建一个新的 AOF 文件，也就是说，读取数据库中的所有键值对，然后对每一个键值对用一条命令记录它的写入。

比如读取了键值对"testkey": "testvalue"后，重写机制会记录 set testkey testvalue 这条命令。

这样，当需要恢复时，可以重新执行该命令，实现"testkey": "testvalue"的写入。

为什么重写机制可以把日志文件变小呢?

实际上，重写机制具有"多变一"功能。所谓的"多变一"，也就是说，旧日志文件中的多条命令，在重写后的新日志中变成了一条命令。我们知道，AOF 文件是以追加的方式，逐一记录接收到的写命令的。当一个键值对被多条写命令反复修改时，AOF 文件会记录相应的多条命令。

但是，在重写的时候，是根据这个键值对当前的最新状态，为它生成对应的写入命令。这样一来，一个键值对在重写日志中只用一条命令就行了，而且，在日志恢复时，只用执行这条命令，就可以直接完成这个键值对的写入了。

当我们对一个列表先后做了 6 次修改操作后，列表的最后状态是["D", "C", "N"]，此时，只用 LPUSH u:list "N", "C", "D"这一条命令就能实现该数据的恢复，这就节省了五条命令的空间。对于被修改过成百上千次的键值对来说，重写能节省的空间当然就更大了。

不过，虽然 AOF 重写后，日志文件会缩小，但是，要把整个数据库的最新数据的操作日志都写回磁盘，仍然是一个非常耗时的过程。

这时，我们就要继续关注另一个问题了：重写会不会阻塞主线程？

★AOF日志重写不会阻塞主线程:一拷贝两日志

和 AOF 日志由主线程写回不同，重写过程是由后台子进程 bgrewriteaof 来完成的。

这也是为了避免阻塞主线程，导致数据库性能下降。

我把重写的过程总结为"一个拷贝，两处日志"。

★1处拷贝:主进程bgrewriteaof去fork子进程

"一个拷贝"就是指，每次执行重写时，主线程 fork 出后台的 bgrewriteaof 子进程。此时，fork 会把主线程的内存拷贝一份给 bgrewriteaof 子进程，这里面就包含了数据库的最新数据。然后，bgrewriteaof 子进程就可以在不影响主线程的情况下，逐一把拷贝的数据写成操作，记入新的AOF重写日志。

★1处日志:旧的正在使用的AOF日志

因为主线程未阻塞，仍然可以处理新来的操作。此时，如果有写操作，第一处日志就是指正在使用的 AOF 日志，Redis 会把这个操作写到它的缓冲区。这样一来，即使宕机了，这个 AOF 日志的操作仍然是齐全的，可以用于恢复。

★2处日志:新的 AOF 重写日志

第二处日志，就是指新的 AOF 重写日志。这个操作会被另外的线程写到重写日志的缓冲区。 这样，重写日志也不会丢失最新的操作。等到拷贝数据的所有操作记录重写完成后，重写日志记录的这些最新操作也会写入新的 AOF 文件，以保证数据库最新状态的记录。此时，我们就可以用新的 AOF 文件替代旧的AOF文件了。

AOF重写实现详解

AOF重写并不需要对原有AOF文件进行任何的读取，写入，分析等操作，这个功能是通过读取服务器当前的数据库状态来实现的。

当前列表键list在数据库中的值就为["C", "D", "E", "F", "G"]。要使用尽量少的命令来记录list键的状态，最简单的方式不是去读取和分析现有AOF文件的内容。那么直接读取list键在数据库中的当前值，然后用一条RPUSH list "C" "D" "E" "F" "G"代替前面的6条命令即可。

原理

首先从数据库中读取键现在的值，然后用一条命令去记录键值对，代替之前记录该键值对的多个命令; 伪代码表示如下;

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()

实际为了避免执行命令时造成客户端输入缓冲区溢出，重写程序在处理list hash set zset等类型的数据时，会检查键所包含的元素的个数，如果元素的数量超过了redis.h/REDIS_AOF_REWRITE_ITEMS_PER_CMD常量的值,该常量默认值是64。

那么重写程序会使用多条命令来记录键的值，而不是单使用一条命令。 即每条命令设置的元素的个数 是最多64个，使用多条命令重写实现集合键中元素数量超过64个的键；

AOF后台重写

aof_rewrite函数可以创建新的AOF文件,但是这个函数会进行大量的写入操作,所以调用这个函数的线程将被长时间的阻塞,因为Redis服务器使用单线程来处理命令请求。

所以如果直接是服务器进程调用AOF_REWRITE函数的话，那么重写AOF期间，服务器将无法处理客户端发送来的命令请求。

Redis不希望AOF重写会造成服务器无法处理请求，所以Redis决定将AOF重写程序放到子进程（后台）里执行。这样处理的最大好处是： 子进程进行AOF重写期间，主进程可以继续处理命令请求。

子进程带有主进程的数据副本，使用子进程而不是线程，可以避免在锁的情况下，保证数据的安全性。

使用子进程进行AOF重写的问题

子进程在进行AOF重写期间，服务器进程还要继续处理命令请求，而新的命令可能对现有的数据进行修改，这会让当前数据库的数据和重写后的AOF文件中的数据不一致。

如何修正

为了解决这种数据不一致的问题，Redis增加了一个AOF重写缓存，这个缓存在fork出子进程之后开始启用，Redis服务器主进程在执行完写命令之后，会同时将这个写命令追加到现有AOF文件和AOF重写缓冲区。 即子进程在执行AOF重写时，主进程需要执行以下三个工作： 执行client发来的命令请求； 将写命令追加到现有的AOF文件中； 将写命令追加到AOF重写缓存中。

效果 可以保证：

AOF缓冲区的内容会定期被写入和同步到AOF文件中，对现有的AOF文件的处理工作会正常进行 从创建子进程开始，服务器执行的所有写操作都会被记录到AOF重写缓冲区中； 完成AOF重写之后 当子进程完成对AOF文件重写之后，它会向父进程发送一个完成信号，父进程接到该完成信号之后，会调用一个信号处理函数，该函数完成以下工作： 1，将AOF重写缓存中的内容全部写入到新的AOF文件中；这个时候新的AOF文件所保存的数据库状态和服务器当前的数据库状态一致； 2，对新的AOF文件进行改名，新的AOF覆盖原有的AOF文件；完成新旧两个AOF文件的替换。 当这个信号处理函数执行完毕之后，主进程就可以继续像往常一样接收命令请求了。在整个AOF后台重写过程中，只有最后的"主进程写入命令到AOF缓存"和"对新的AOF文件进行改名，覆盖原有的AOF文件。"这两个步骤（信号处理函数执行期间）会造成主进程阻塞，在其他时候，AOF后台重写都不会对主进程造成阻塞，这将AOF重写对性能造成的影响降到最低。 以上，即AOF后台重写，也就是BGREWRITEAOF命令的工作原理。

原文链接：blog.csdn.net/m0_45861545...

小结

Redis通过AOF 方法逐一记录操作命令,用于避免数据丢失的,在恢复时再逐一执行命令的方式，保证了数据的可靠性。

这个方法看似"简单"，但也是充分考虑了对 Redis 性能的影响。总结来说，它提供了 AOF 日志的三种写回策略，分别是 Always、Everysec 和 No，这三种策略在可靠性上是从高到低，而在性能上则是从低到高。

此外，为了避免日志文件过大，Redis 还提供了 AOF 重写机制，直接根据数据库里数据的最新状态，生成这些数据的插入命令，作为新日志。这个过程通过后台线程完成，避免了对主线程的阻塞。

其中，三种写回策略体现了系统设计中的一个重要原则 ，即 trade-off，或者称为"取舍"，指的就是在性能和可靠性保证之间做取舍。我认为，这是做系统设计和开发的一个关键哲学，我也非常希望，你能充分地理解这个原则，并在日常开发中加以应用。

不过，你可能也注意到了，落盘时机和重写机制都是在"记日志"这一过程中发挥作用的。例如，落盘时机的不选择同步写回可以避免记日志时阻塞主线程，重写可以避免日志文件过大。

但是，在"用日志"的过程中，也就是使用 AOF 进行故障恢复时，我们仍然需要把所有的操作记录都运行一遍。再加上 Redis 的单线程设计，这些命令操作只能一条一条按顺序执行，这个"重放"的过程就会很慢了。那么，有没有既能避免数据丢失，又能更快地恢复的方法呢？当然有，那就是 RDB 快照了。