redis 源码系列（15）：快照 + 增量记录 --- AOF

最新推荐文章于 2023-11-13 17:56:15 发布

置顶 maohuazhu

最新推荐文章于 2023-11-13 17:56:15 发布

阅读量502

点赞数

文章标签： redis c语言

本文链接：https://blog.csdn.net/qq_16205285/article/details/103971210

版权

在介绍 rdb 的文章中，我们提到 rdb 并不能完美的解决 redis 持久化的问题。因为其只是 redis 数据库的某一时刻的快照，而且因为 rdb 的 dump 过程往往会消耗大量的服务器资源，所以一般都是在业务低峰期进行，而且不会很频繁，一般都是以天为单位来进行。redis 在 dump 两次 rdb 之间，可能会丢失大量的数据。

所以 redis 提供了另一种持久化手段，即 append only file（AOF），也是今天的主角。不同于 rdb 是数据库某一刻的状态快照，AOF 以日志的形式，将数据库的数据将命令的格式保存到文件，在 reload 的时候只需要 replay AOF 中的命令即可。

AOF

传播命令

在 redis.c 中的有一个传播函数，负责将 redis 处理的命令传播到 aof 和 slave 中:

void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
               int flags)
{
    // 传播到 AOF
    if (server.aof_state != REDIS_AOF_OFF && flags & REDIS_PROPAGATE_AOF)
        feedAppendOnlyFile(cmd,dbid,argv,argc);

    // 传播到 slave
    if (flags & REDIS_PROPAGATE_REPL)
        replicationFeedSlaves(server.slaves,dbid,argv,argc);
}

void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) {
    sds buf = sdsempty();
    robj *tmpargv[3];
		// 如果当前命令需要更换 redis database，先写入一个 select command
    if (dictid != server.aof_selected_db) {
        char seldb[64];
        snprintf(seldb,sizeof(seldb),"%d",dictid);
        buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%lu\r\n%s\r\n",
            (unsigned long)strlen(seldb),seldb);
        server.aof_selected_db = dictid;
    }
    if (cmd->proc == expireCommand || cmd->proc == pexpireCommand ||
        cmd->proc == expireatCommand) {
  			// 将 expire、pexpire、expireat 命令都转为等价的 PEXPIREAT 命令
        buf = catAppendOnlyExpireAtCommand(buf,cmd,argv[1],argv[2]);
    } else if (cmd->proc == setexCommand || cmd->proc == psetexCommand) {
        // 将 setex 和 psetex 命令转换为 SET + PEXPIREAT 命令
        tmpargv[0] = createStringObject("SET",3);
        tmpargv[1] = argv[1];
        tmpargv[2] = argv[3];
        buf = catAppendOnlyGenericCommand(buf,3,tmpargv);
        // PEXPIREAT
        decrRefCount(tmpargv[0]);
        buf = catAppendOnlyExpireAtCommand(buf,cmd,argv[1],argv[2]);
    } else {
        // 其他命令都不需要转换
        buf = catAppendOnlyGenericCommand(buf,argc,argv);
    }

    // 将重新构建的命令写入到 AOF 缓存内
    if (server.aof_state == REDIS_AOF_ON)
        server.aof_buf = sdscatlen(server.aof_buf,buf,sdslen(buf));

    // 如果后台的 aof rewrite 正在进行，我们还需要将数据写入到 aof rewrite buffer list 中
    if (server.aof_child_pid != -1)
        aofRewriteBufferAppend((unsigned char*)buf,sdslen(buf));

    // 释放
    sdsfree(buf);
}

sds catAppendOnlyGenericCommand(sds dst, int argc, robj **argv) {
    char buf[32];
    int len, j;
    robj *o;
    // 重建命令的个数，格式为 *<count>\r\n
    buf[0] = '*';
    len = 1+ll2string(buf+1,sizeof(buf)-1,argc);
    buf[len++] = '\r';
    buf[len++] = '\n';
    dst = sdscatlen(dst,buf,len);
    // 将所有命令转化为字符串表示，并且拼接起来
    // 单条命令的格式：$<length>\r\n<content>\r\n
    for (j = 0; j < argc; j++) {
        o = getDecodedObject(argv[j]);
        // 组合 $<length>\r\n
        buf[0] = '$';
        len = 1+ll2string(buf+1,sizeof(buf)-1,sdslen(o->ptr));
        buf[len++] = '\r';
        buf[len++] = '\n';
        dst = sdscatlen(dst,buf,len);
        // 组合 <content>\r\n
        dst = sdscatlen(dst,o->ptr,sdslen(o->ptr));
        dst = sdscatlen(dst,"\r\n",2);
        decrRefCount(o);
    }
    // 返回重建后的协议内容
    return dst;
}

写入 AOF 缓存到文件

每次在 redis 进入 eventloop 等待处理客户端请求前，都会检查是否需要 flush aof 缓存：

void beforeSleep(struct aeEventLoop *eventLoop) {
    REDIS_NOTUSED(eventLoop);
    // 略过不想干代码
    // 将 AOF 缓冲区的内容写入到 AOF 文件
    flushAppendOnlyFile(0);
    /* Call the Redis Cluster before sleep function. */
    // 在进入下个事件循环前，执行一些集群收尾工作
    if (server.cluster_enabled) clusterBeforeSleep();
}
// flush aof buf 到 aof 文件
void flushAppendOnlyFile(int force) {
    ssize_t nwritten;
    int sync_in_progress = 0;
    // 缓冲区中没有任何内容，直接返回
    if (sdslen(server.aof_buf) == 0) return;
    // 策略为每秒 FSYNC 
    if (server.aof_fsync == AOF_FSYNC_EVERYSEC)
        // 是否有 SYNC 正在后台进行？
        sync_in_progress = bioPendingJobsOfType(REDIS_BIO_AOF_FSYNC) != 0;

    // 每秒 fsync ，并且强制写入为假
    if (server.aof_fsync == AOF_FSYNC_EVERYSEC && !force) {
        // 如果后台有尚未进行的 AOF 任务，而且这次不是强制写入，我们可能 delay flush
        if (sync_in_progress) {
            if (server.aof_flush_postponed_start == 0) {
                // 如果没有 delay 的 flush 任务，我们设置 aof_flush_postponed_start 为当前时间
                // 本次 flush 操作被 delay
                server.aof_flush_postponed_start = server.unixtime;
                return;

            } else if (server.unixtime - server.aof_flush_postponed_start < 2) {
                // 如果之前的 delay 操作距离现在不足 2s，我们也不处理本次 flush
                return;

            }
					  // 否则即使后台有待完成的任务，我们也要强制 flush，记录 delayed fsync
            server.aof_delayed_fsync++;
            redisLog(REDIS_NOTICE,"Asynchronous AOF fsync is taking too long (disk is busy?). Writing the AOF buffer without waiting for fsync to complete, this may slow down Redis.");
        }
    }
    // 清除 delay flush 的标示
    server.aof_flush_postponed_start = 0;
		// 将 aof buf 写入到文件中，在一个正常的文件系统中，这个写入应该是原子的，而且不应该出现 short write
    // 注意 write 和 sync 是不同的，write 是无法保证写入数据已经落盘的
    nwritten = write(server.aof_fd,server.aof_buf,sdslen(server.aof_buf));
    if (nwritten != (signed)sdslen(server.aof_buf)) {
        // short write 或者出错，需要处理
        static time_t last_write_error_log = 0;
        int can_log = 0;
        // 将日志的记录频率限制在每行 AOF_WRITE_LOG_ERROR_RATE 秒
        if ((server.unixtime - last_write_error_log) > AOF_WRITE_LOG_ERROR_RATE) {
            can_log = 1;
            last_write_error_log = server.unixtime;
        }
        if (nwritten == -1) {
            // 如果写入出错，那么尝试将该情况写入到日志里面
            if (can_log) {
                redisLog(REDIS_WARNING,"Error writing to the AOF file: %s",
                    strerror(errno));
                server.aof_last_write_errno = errno;
            }
        } else {
            // short write，如果需要记录日志的话，输出日志
            if (can_log) {
                redisLog(REDIS_WARNING,"Short write while writing to "
                                       "the AOF file: (nwritten=%lld, "
                                       "expected=%lld)",
                                       (long long)nwritten,
                                       (long long)sdslen(server.aof_buf));
            }
            // 尝试移除新追加的不完整内容，保持 AOF 的有效性
            if (ftruncate(server.aof_fd, server.aof_current_size) == -1) {
                // 移除失败，记录日志
                if (can_log) {
                    redisLog(REDIS_WARNING, "Could not remove short write "
                             "from the append-only file.  Redis may refuse "
                             "to load the AOF the next time it starts.  "
                             "ftruncate: %s", strerror(errno));
                }
            } else {
                nwritten = -1;
            }
            server.aof_last_write_errno = ENOSPC;
        }
        if (server.aof_fsync == AOF_FSYNC_ALWAYS) {
            // 如果 aof sync 策略是 always 的话，这个错误是无法恢复的
            // 因为这个配置代表了我们希望每一次写入 aof 文件，都必须进行成功的 sync，直接退出程序
            redisLog(REDIS_WARNING,"Can't recover from AOF write error when the AOF fsync policy is 'always'. Exiting...");
            exit(1);
        } else {
            // 其他 sync 策略则可以恢复，我们设置 aof_last_write_status
            // redis 在下次成功写入之前不再接受 write 类型的命令
            server.aof_last_write_status = REDIS_ERR;
            // 如果发生了short write，而且 truncate 也失败了，那么更新 aof_buf 和 aof_current_size
            if (nwritten > 0) {
                server.aof_current_size += nwritten;
                sdsrange(server.aof_buf,nwritten,-1);
            }
            return; /* We'll try again on the next call... */
        }
    } else {
        // 写入成功，更新最后写入状态
        if (server.aof_last_write_status == REDIS_ERR) {
            redisLog(REDIS_WARNING,
                "AOF write error looks solved, Redis can write again.");
            server.aof_last_write_status = REDIS_OK;
        }
    }

    // 更新写入后的 AOF 文件大小
    server.aof_current_size += nwritten;
		// 我们不希望 aof_buf 占用太多内存，如果占用内存不超过 4000 bytes，就复用当前 aof_buf
    // 否则释放当前 aof_buf 并且新创建一个空缓存
    if ((sdslen(server.aof_buf)+sdsavail(server.aof_buf)) < 4000) {
        sdsclear(server.aof_buf);
    } else {
        sdsfree(server.aof_buf);
        server.aof_buf = sdsempty();
    }
		// 如果设置了 aof_no_fsync_on_rewrite 而且后台有正在进行的 aof rewrite 或者 bgsave，不要进行 fsync
    if (server.aof_no_fsync_on_rewrite &&
        (server.aof_child_pid != -1 || server.rdb_child_pid != -1))
            return;

    // 如果满足条件，执行 fsync 
    if (server.aof_fsync == AOF_FSYNC_ALWAYS) {
        // 每次写入 aof 都执行 sync，那么我们不能将 fsync 放到后台线程
        // 因为 always 的语意是说每次 flush 调用后，数据必然已经完成落盘
        aof_fsync(server.aof_fd); /* Let's try to get this data on the disk */
        // 更新最后一次执行 fsnyc 的时间
        server.aof_last_fsync = server.unixtime;
    } else if ((server.aof_fsync == AOF_FSYNC_EVERYSEC &&
                server.unixtime > server.aof_last_fsync)) {
        // 策略为每秒 fsnyc ，并且距离上次 fsync 已经超过 1 秒，如果后台没有 sync 任务，创建后台任务
        if (!sync_in_progress) aof_background_fsync(server.aof_fd);
        // 更新最后一次执行 fsync 的时间
        server.aof_last_fsync = server.unixtime;
    }
}

void aof_background_fsync(int fd) {
    bioCreateBackgroundJob(REDIS_BIO_AOF_FSYNC,(void*)(long)fd,NULL,NULL);
}

要注意，向 AOF 缓存添加数据是发生在我们时间循环处理中处理客户端命令时，但是每次 flushAppendOnlyFile 则是发生在进入 eventloop（beforeSleep）前。所以我们在某个命令中对 AOF 的修改，要在命令全部处理完后，下一次时间循环前，才可以进行写入。这也是 redis 不具有（100%）持久性的原因，因为它的写入和处理命令是异步的，即使启用 always sync 的策略，仍然不能保证没有数据丢失。

关于 flush 函数还有一个很重要的优化点，就是将 fsync 放到后台线程（是的，虽然我一直说 redis 是单线程，但是我撒谎了）去做，这么做是为了避免 fsync 阻塞主线程太多时间。

bio

redis 将一些与本地文件相关的阻塞操作(close，fsync），放到了后台线程中去处理，来避免对主线程长时间的阻塞，相关代码在 src/bio.c 中。

bio 相关接口的实现是非常简单以及直观的:

static pthread_t bio_threads[REDIS_BIO_NUM_OPS];
static pthread_mutex_t bio_mutex[REDIS_BIO_NUM_OPS];
static pthread_cond_t bio_condvar[REDIS_BIO_NUM_OPS];
// 待处理任务
static list *bio_jobs[REDIS_BIO_NUM_OPS];
// 记录每种类型 job 队列里有多少 job 等待执行
static unsigned long long bio_pending[REDIS_BIO_NUM_OPS];
// 待处理任务结构体
struct bio_job {
    // 任务创建时的时间
    time_t time; /* Time at which the job was created. */
    // 任务参数
    void *arg1, *arg2, *arg3;
};

void *bioProcessBackgroundJobs(void *arg);
// 子线程栈大小
#define REDIS_THREAD_STACK_SIZE (1024*1024*4)
// 初始化 bio 模块
void bioInit(void) {
    pthread_attr_t attr;
    pthread_t thread;
    size_t stacksize;
    int j;
    // 每一种 bio 任务需要创建一个后台线程，初始化其对应的资源 mutex、cond
    for (j = 0; j < REDIS_BIO_NUM_OPS; j++) {
        pthread_mutex_init(&bio_mutex[j],NULL);
        pthread_cond_init(&bio_condvar[j],NULL);
        bio_jobs[j] = listCreate();
        bio_pending[j] = 0;
    }
		// 设置栈大小
    pthread_attr_init(&attr);
    pthread_attr_getstacksize(&attr,&stacksize);
    if (!stacksize) stacksize = 1; /* The world is full of Solaris Fixes */
    while (stacksize < REDIS_THREAD_STACK_SIZE) stacksize *= 2;
    pthread_attr_setstacksize(&attr, stacksize);

    // 为每一个任务创建后台线程
    for (j = 0; j < REDIS_BIO_NUM_OPS; j++) {
        void *arg = (void*)(unsigned long) j;
        if (pthread_create(&thread,&attr,bioProcessBackgroundJobs,arg) != 0) {
            redisLog(REDIS_WARNING,"Fatal: Can't initialize Background Jobs.");
            exit(1);
        }
        bio_threads[j] = thread;
    }
}
// 创建后台任务
void bioCreateBackgroundJob(int type, void *arg1, void *arg2, void *arg3) {
    struct bio_job *job = zmalloc(sizeof(*job));
    job->time = time(NULL);
    job->arg1 = arg1;
    job->arg2 = arg2;
    job->arg3 = arg3;
    // 加锁，将任务推入队列，等待对应后台线程处理
    pthread_mutex_lock(&bio_mutex[type]);
    listAddNodeTail(bio_jobs[type],job);
    bio_pending[type]++;
    pthread_cond_signal(&bio_condvar[type]);
    pthread_mutex_unlock(&bio_mutex[type]);
}
// 后台处理线程
void *bioProcessBackgroundJobs(void *arg) {
    struct bio_job *job;
    unsigned long type = (unsigned long) arg;
    sigset_t sigset;
    // 主动 kill 一个 thread 是很少见的，一般并不推荐使用这种方式
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
    pthread_mutex_lock(&bio_mutex[type]);
    // 屏蔽 SIGALRM，确保主线程处理 SIGALRM（多线程和信号真的是很难办）
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGALRM);
    if (pthread_sigmask(SIG_BLOCK, &sigset, NULL))
        redisLog(REDIS_WARNING,
            "Warning: can't mask SIGALRM in bio.c thread: %s", strerror(errno));
		// 死循环，开始处理任务
    while(1) {
        listNode *ln;
        // 等待新任务
        if (listLength(bio_jobs[type]) == 0) {
            pthread_cond_wait(&bio_condvar[type],&bio_mutex[type]);
            continue;
        }
				// 从任务队列取出任务
        ln = listFirst(bio_jobs[type]);
        job = ln->value;
        pthread_mutex_unlock(&bio_mutex[type]);
				// 执行对应任务
        if (type == REDIS_BIO_CLOSE_FILE) {
            close((long)job->arg1);
        } else if (type == REDIS_BIO_AOF_FSYNC) {
            aof_fsync((long)job->arg1);
        } else {
            redisPanic("Wrong job type in bioProcessBackgroundJobs().");
        }

        zfree(job);
        /* Lock again before reiterating the loop, if there are no longer
         * jobs to process we'll block again in pthread_cond_wait(). */
        pthread_mutex_lock(&bio_mutex[type]);
        // 将执行完成的任务从队列中删除，并减少任务计数器
        listDelNode(bio_jobs[type],ln);
        bio_pending[type]--;
    }
}
// 查看 type 对应的 pending 后台任务
unsigned long long bioPendingJobsOfType(int type) {
    unsigned long long val;

    pthread_mutex_lock(&bio_mutex[type]);
    val = bio_pending[type];
    pthread_mutex_unlock(&bio_mutex[type]);
    return val;
}

// 杀死线程
void bioKillThreads(void) {
    int err, j;

    for (j = 0; j < REDIS_BIO_NUM_OPS; j++) {
        if (pthread_cancel(bio_threads[j]) == 0) {
            if ((err = pthread_join(bio_threads[j],NULL)) != 0) {
                redisLog(REDIS_WARNING,
                    "Bio thread for job type #%d can be joined: %s",
                        j, strerror(err));
            } else {
                redisLog(REDIS_WARNING,
                    "Bio thread for job type #%d terminated",j);
            }
        }
    }
}

bio 为每一个后台 blocking io 操作都创建了一个后台线程，并且使用一个简单的任务队列与主线程通信。可以说是一个非常简单的类似线程池的实现，对于任何有多线程编程经验的人，上述的代码都不会有陌生的地方。

AOF load

如果开启了 AOF ， redis 启动的时候就会从 AOF 文件恢复数据：

void loadDataFromDisk(void) {
    // 记录开始时间
    long long start = ustime();
    if (server.aof_state == REDIS_AOF_ON) {
        // AOF 持久化已打开？尝试载入 AOF 文件
        if (loadAppendOnlyFile(server.aof_filename) == REDIS_OK)
            // 打印载入信息，并计算载入耗时长度
            redisLog(REDIS_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);
    } else {
        // AOF 持久化未打开 尝试载入 RDB 文件
        if (rdbLoad(server.rdb_filename) == REDIS_OK) {
            // 打印载入信息，并计算载入耗时长度
            redisLog(REDIS_NOTICE,"DB loaded from disk: %.3f seconds",
                (float)(ustime()-start)/1000000);
        } else if (errno != ENOENT) {
            redisLog(REDIS_WARNING,"Fatal error loading the DB: %s. Exiting.",strerror(errno));
            exit(1);
        }
    }
}

int loadAppendOnlyFile(char *filename) {
    // 执行命令需要客户端，构造一个伪客户端
    struct redisClient *fakeClient;
    // 打开 AOF 文件
    FILE *fp = fopen(filename,"r");
    struct redis_stat sb;
    int old_aof_state = server.aof_state;
    long loops = 0;
    // 检查文件的正确性
    if (fp && redis_fstat(fileno(fp),&sb) != -1 && sb.st_size == 0) {
        server.aof_current_size = 0;
        fclose(fp);
        return REDIS_ERR;
    }
    // 检查文件是否正常打开
    if (fp == NULL) {
        redisLog(REDIS_WARNING,"Fatal error: can't open the append log file for reading: %s",strerror(errno));
        exit(1);
    }
		// 关闭 aof 标志，防止执行过程中，又有命令传播到 aof
    server.aof_state = REDIS_AOF_OFF;
    fakeClient = createFakeClient();
    // 设置服务器的状态为：正在载入
    startLoading(fp);
    while(1) {
        int argc, j;
        unsigned long len;
        robj **argv;
        char buf[128];
        sds argsds;
        struct redisCommand *cmd;
        // 间隔性的处理客户端请求，但是处于 loading 态的 redis 只能执行部分命令
        if (!(loops++ % 1000)) {
            loadingProgress(ftello(fp));
            processEventsWhileBlocked();
        }
        // 读入文件内容到缓存
        if (fgets(buf,sizeof(buf),fp) == NULL) {
            if (feof(fp))
                // 文件已经读完，跳出
                break;
            else
                goto readerr;
        }
        // 确认协议格式，比如 *3\r\n
        if (buf[0] != '*') goto fmterr;
        // 取出命令参数，比如 *3\r\n 中的 3
        argc = atoi(buf+1);
        // 至少要有一个参数（被调用的命令）
        if (argc < 1) goto fmterr;
        // 从文本中创建字符串对象：包括命令，以及命令参数
        // 例如 $3\r\nSET\r\n$3\r\nKEY\r\n$5\r\nVALUE\r\n
        // 将创建三个包含以下内容的字符串对象：
        // SET 、 KEY 、 VALUE
        argv = zmalloc(sizeof(robj*)*argc);
        for (j = 0; j < argc; j++) {
            if (fgets(buf,sizeof(buf),fp) == NULL) goto readerr;

            if (buf[0] != '$') goto fmterr;

            // 读取参数值的长度
            len = strtol(buf+1,NULL,10);
            // 读取参数值
            argsds = sdsnewlen(NULL,len);
            if (len && fread(argsds,len,1,fp) == 0) goto fmterr;
            // 为参数创建对象
            argv[j] = createObject(REDIS_STRING,argsds);

            if (fread(buf,2,1,fp) == 0) goto fmterr; /* discard CRLF */
        }
				// 查找命令对应的 command 结构体
        cmd = lookupCommand(argv[0]->ptr);
        if (!cmd) {
            redisLog(REDIS_WARNING,"Unknown command '%s' reading the append only file", (char*)argv[0]->ptr);
            exit(1);
        }
				// 通过伪客户端执行命令，redis 命令的执行必须通过客户端
        fakeClient->argc = argc;
        fakeClient->argv = argv;
        cmd->proc(fakeClient);
        // 伪客户端不应该有返回数据
        redisAssert(fakeClient->bufpos == 0 && listLength(fakeClient->reply) == 0);
        // 不应该处于阻塞
      	redisAssert((fakeClient->flags & REDIS_BLOCKED) == 0);
				// 清理数据
        for (j = 0; j < fakeClient->argc; j++)
            decrRefCount(fakeClient->argv[j]);
        zfree(fakeClient->argv);
    }
    // 执行完 AOF 命令，应该没有未完结的 MULTI 事务
    if (fakeClient->flags & REDIS_MULTI) goto readerr;
    // 关闭 AOF 文件
    fclose(fp);
    // 释放伪客户端
    freeFakeClient(fakeClient);
    // 复原 AOF 状态
    server.aof_state = old_aof_state;
    // 停止载入
    stopLoading();
    // 更新服务器状态中， AOF 文件的当前大小
    aofUpdateCurrentSize();
    // 记录前一次重写时的大小
    server.aof_rewrite_base_size = server.aof_current_size;
    return REDIS_OK;
// 读入错误
readerr:
    // 非预期的末尾，可能是 AOF 文件在写入的中途遭遇了停机
    if (feof(fp)) {
        redisLog(REDIS_WARNING,"Unexpected end of file reading the append only file");
    
    // 文件内容出错
    } else {
        redisLog(REDIS_WARNING,"Unrecoverable error reading the append only file: %s", strerror(errno));
    }
    exit(1);
// 内容格式错误
fmterr:
    redisLog(REDIS_WARNING,"Bad file format reading the append only file: make a backup of your AOF file, then use ./redis-check-aof --fix <filename>");
    exit(1);
}

在传播命令到 AOF 文件中我们就看到了，AOF 数据就是编码以后的命令文本。加载 AOF 文件的过程就是通过 replay 这些命令从新构建数据库的过程。

AOF rewrite

AOF 通过不断的传播命令到文件中，必然会导致文件大小的不断膨胀，加载时间也会不断延长。而且 AOF 中的数据会存在很多不必要的冗余，比如对同一个 key 的重复赋值，并不需要保留对其的所有赋值命令，而只需要保留最后一个赋值命令就可以了。所以 redis 实现了 AOF rewrite 机制，来定期重写 AOF 文件.

AOF rewrite buffer

当 AOF rewrite 正在进行时，redis 会将 AOF 开始后产生的 AOF 数据写入到 AOF rewrite buffer 中：

#define AOF_RW_BUF_BLOCK_SIZE (1024*1024*10)    /* 10 MB per block */

typedef struct aofrwblock {
    // 缓存块已使用字节数和可用字节数
    unsigned long used, free;
    // 缓存块
    char buf[AOF_RW_BUF_BLOCK_SIZE];
} aofrwblock;
// 重置 aof buffer list
void aofRewriteBufferReset(void) {
    // 释放旧有的缓存（链表）
    if (server.aof_rewrite_buf_blocks)
        listRelease(server.aof_rewrite_buf_blocks);
    // 初始化新的缓存（链表）
    server.aof_rewrite_buf_blocks = listCreate();
    listSetFreeMethod(server.aof_rewrite_buf_blocks,zfree);
}
// 返回当前 aof buffer 大小
unsigned long aofRewriteBufferSize(void) {
    // 计算公式 (len(bufferlist)-1) * AOF_RW_BUF_BLOCK_SIZE + used of last buffer
    // 取出链表中最后的缓存块
    listNode *ln = listLast(server.aof_rewrite_buf_blocks);
    aofrwblock *block = ln ? ln->value : NULL;
    // 没有缓存被使用
    if (block == NULL) return 0;
    // 总缓存大小 = （缓存块数量-1） * AOF_RW_BUF_BLOCK_SIZE + 最后一个缓存块的大小
    unsigned long size =
        (listLength(server.aof_rewrite_buf_blocks)-1) * AOF_RW_BUF_BLOCK_SIZE;
    size += block->used;
    return size;
}
// 向 buffer list 末尾添加缓存
void aofRewriteBufferAppend(unsigned char *s, unsigned long len) {
    // 指向最后一个缓存块
    listNode *ln = listLast(server.aof_rewrite_buf_blocks);
    aofrwblock *block = ln ? ln->value : NULL;
    while(len) {
				// 如果 buffer list 末尾有未用完的 block，先写入到这个 block
        if (block) {
            unsigned long thislen = (block->free < len) ? block->free : len;
            if (thislen) {  /* The current block is not already full. */
                memcpy(block->buf+block->used, s, thislen);
                block->used += thislen;
                block->free -= thislen;
                s += thislen;
                len -= thislen;
            }
        }
				// 到这里，已经将 buffer list 原先可能未使用的 block 写满，
        // 如果 len != 0 那么需要申请新的 block
        if (len) { /* First block to allocate, or need another block. */
            int numblocks;
            // 分配缓存块
            block = zmalloc(sizeof(*block));
            block->free = AOF_RW_BUF_BLOCK_SIZE;
            block->used = 0;
            // 链接到链表末尾
            listAddNodeTail(server.aof_rewrite_buf_blocks,block);
						// 每创建 10 个 buffer block 就记录一次日志
            numblocks = listLength(server.aof_rewrite_buf_blocks);
            if (((numblocks+1) % 10) == 0) {
                int level = ((numblocks+1) % 100) == 0 ? REDIS_WARNING :
                                                         REDIS_NOTICE;
                redisLog(level,"Background AOF buffer size: %lu MB",
                    aofRewriteBufferSize()/(1024*1024));
            }
        }
    }
}
// 将 aof 数据写入到 fd
ssize_t aofRewriteBufferWrite(int fd) {
    listNode *ln;
    listIter li;
    ssize_t count = 0;
    // 遍历所有缓存块
    listRewind(server.aof_rewrite_buf_blocks,&li);
    while((ln = listNext(&li))) {
        aofrwblock *block = listNodeValue(ln);
        ssize_t nwritten;
        if (block->used) {
            // 写入缓存块内容到 fd
            nwritten = write(fd,block->buf,block->used);
            if (nwritten != block->used) {
                if (nwritten == 0) errno = EIO;
                return -1;
            }
            // 积累写入字节
            count += nwritten;
        }
    }
    return count;
}

下面来看如何执行 AOF rewrite

// AOF rewrite 的实现其实很简单，其与 rdb 有点相似，主要区别只是 dump 文件的编码方式
int rewriteAppendOnlyFile(char *filename) {
    dictIterator *di = NULL;
    dictEntry *de;
    rio aof;
    FILE *fp;
    char tmpfile[256];
    int j;
    long long now = mstime();
    // 与 rdb 文件一个套路，先创建 tmp 文件，rewrite 结束后再原子地改名 
    snprintf(tmpfile,256,"temp-rewriteaof-%d.aof", (int) getpid());
    fp = fopen(tmpfile,"w");
    if (!fp) {
        redisLog(REDIS_WARNING, "Opening the temp file for AOF rewrite in rewriteAppendOnlyFile(): %s", strerror(errno));
        return REDIS_ERR;
    }
    // 初始化文件 io
    rioInitWithFile(&aof,fp);
    // 设置自动 sync 的字节上限
    if (server.aof_rewrite_incremental_fsync)
        rioSetAutoSync(&aof,REDIS_AOF_AUTOSYNC_BYTES);
    // 遍历所有数据库
    for (j = 0; j < server.dbnum; j++) {
        char selectcmd[] = "*2\r\n$6\r\nSELECT\r\n";
        redisDb *db = server.db+j;
        // 指向键空间
        dict *d = db->dict;
        if (dictSize(d) == 0) continue;
        // 创建键空间迭代器
        di = dictGetSafeIterator(d);
        if (!di) {
            fclose(fp);
            return REDIS_ERR;
        }
        // 先写入 select 命令
        if (rioWrite(&aof,selectcmd,sizeof(selectcmd)-1) == 0) goto werr;
        if (rioWriteBulkLongLong(&aof,j) == 0) goto werr;
        // 遍历 database 写入其内所有 key 
        while((de = dictNext(di)) != NULL) {
            sds keystr;
            robj key, *o;
            long long expiretime;
            // 取出键
            keystr = dictGetKey(de);
            // 取出值
            o = dictGetVal(de);
            initStaticStringObject(key,keystr);
            // 取出过期时间
            expiretime = getExpire(db,&key);
            // 过期的键不需要保存
            if (expiretime != -1 && expiretime < now) continue;
						// 根据值类型，构造不同的命令保存
            if (o->type == REDIS_STRING) {
                /* Emit a SET command */
                char cmd[]="*3\r\n$3\r\nSET\r\n";
                if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
                if (rioWriteBulkObject(&aof,&key) == 0) goto werr;
                if (rioWriteBulkObject(&aof,o) == 0) goto werr;
            } else if (o->type == REDIS_LIST) {
                if (rewriteListObject(&aof,&key,o) == 0) goto werr;
            } else if (o->type == REDIS_SET) {
                if (rewriteSetObject(&aof,&key,o) == 0) goto werr;
            } else if (o->type == REDIS_ZSET) {
                if (rewriteSortedSetObject(&aof,&key,o) == 0) goto werr;
            } else if (o->type == REDIS_HASH) {
                if (rewriteHashObject(&aof,&key,o) == 0) goto werr;
            } else {
                redisPanic("Unknown object type");
            }
						// 有过期时间的话用 PEZPIREAT 保存过期时间
            if (expiretime != -1) {
                char cmd[]="*3\r\n$9\r\nPEXPIREAT\r\n";
                // 写入 PEXPIREAT expiretime 命令
                if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
                if (rioWriteBulkObject(&aof,&key) == 0) goto werr;
                if (rioWriteBulkLongLong(&aof,expiretime) == 0) goto werr;
            }
        }
        // 释放迭代器
        dictReleaseIterator(di);
    }
    // 确保写入内容落盘
    if (fflush(fp) == EOF) goto werr;
    if (aof_fsync(fileno(fp)) == -1) goto werr;
    if (fclose(fp) == EOF) goto werr;
    // 原子改名
    if (rename(tmpfile,filename) == -1) {
        redisLog(REDIS_WARNING,"Error moving temp append only file on the final destination: %s", strerror(errno));
        unlink(tmpfile);
        return REDIS_ERR;
    }
    redisLog(REDIS_NOTICE,"SYNC append only file rewrite performed");
    return REDIS_OK;
werr:
    fclose(fp);
    unlink(tmpfile);
    redisLog(REDIS_WARNING,"Write error writing append only file on disk: %s", strerror(errno));
    if (di) dictReleaseIterator(di);
    return REDIS_ERR;
}
/*
	AOF rewrite 在后台启动的流程如下：
	1.用户调用 BGREWRITEAOF
	2.redis 调用 rewriteAppendOnlyFileBackground，fork rewrite aof 的子进程
	3.子进程完成后，通过信号通知 redis 进程
	4.如果子进程正常退出，将 rewrite buffer 里面的新数据写入到临时文件，完成后替换 AOF 文件
*/
int rewriteAppendOnlyFileBackground(void) {
    pid_t childpid;
    long long start;
    // 已经有进程在进行 AOF 重写了
    if (server.aof_child_pid != -1) return REDIS_ERR;
    // 记录 fork 开始前的时间，计算 fork 耗时用
    start = ustime();
    if ((childpid = fork()) == 0) {
        char tmpfile[256];
        // 关闭网络连接 fd
        closeListeningSockets(0);
        // 为进程设置名字，方便记认
        redisSetProcTitle("redis-aof-rewrite");
        // 创建临时文件，并进行 AOF 重写
        snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) getpid());
        if (rewriteAppendOnlyFile(tmpfile) == REDIS_OK) {
            size_t private_dirty = zmalloc_get_private_dirty();

            if (private_dirty) {
                redisLog(REDIS_NOTICE,
                    "AOF rewrite: %zu MB of memory used by copy-on-write",
                    private_dirty/(1024*1024));
            }
            // 发送重写成功信号
            exitFromChild(0);
        } else {
            // 发送重写失败信号
            exitFromChild(1);
        }
    } else {
        // 记录执行 fork 所消耗的时间
        server.stat_fork_time = ustime()-start;

        if (childpid == -1) {
            redisLog(REDIS_WARNING,
                "Can't rewrite append only file in background: fork: %s",
                strerror(errno));
            return REDIS_ERR;
        }
        redisLog(REDIS_NOTICE,
            "Background append only file rewriting started by pid %d",childpid);
        // 记录 AOF 重写的信息
        server.aof_rewrite_scheduled = 0;
        server.aof_rewrite_time_start = time(NULL);
        server.aof_child_pid = childpid;
        // 关闭字典自动 rehash
        updateDictResizePolicy();
				// aof_selected_db 设置为 -1 会让后续传播命令到 rewrite buffer 的时候以一个 select 命令开始
        server.aof_selected_db = -1;
        replicationScriptCacheFlush();
        return REDIS_OK;
    }
    return REDIS_OK; /* unreached */
}
// AOF rewrite 子进程退出以后父进程调用
void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
    if (!bysignal && exitcode == 0) {
        // AOF rewrite 子进程正常退出
        int newfd, oldfd;
        char tmpfile[256];
        long long now = ustime();
        redisLog(REDIS_NOTICE,
            "Background AOF rewrite terminated with success");
        // 打开保存新 AOF 文件内容的临时文件
        snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof",
            (int)server.aof_child_pid);
        newfd = open(tmpfile,O_WRONLY|O_APPEND);
        if (newfd == -1) {
            redisLog(REDIS_WARNING,
                "Unable to open the temporary AOF produced by the child: %s", strerror(errno));
            goto cleanup;
        }
        // 当启动 AOF rewrite 后台进程之后，AOF 的数据也会写入到 AOF rewrite buffer 中
        // 将这些 AOF 新数据也写入到新的 AOF 文件中，注意在这个时候 redis 不会处理任何新任务
        // 所以 AOF rewrite 时是 redis 的快照数据，后续新加入的增量写数据，合并起来就可以重新构建数据库
        if (aofRewriteBufferWrite(newfd) == -1) {
            redisLog(REDIS_WARNING,
                "Error trying to flush the parent diff to the rewritten AOF: %s", strerror(errno));
            close(newfd);
            goto cleanup;
        }

        redisLog(REDIS_NOTICE,
            "Parent diff successfully flushed to the rewritten AOF (%lu bytes)", aofRewriteBufferSize());
				// 后续我们只需要将这个 tmp 文件 rename 即可完成 AOF rewrite，但是在 rename 时
        // 我们要避免因为 rename 导致删除原来的 AOF 文件，这个删除可能会阻塞我们的进程很长时间
        // 存在下述两种情况
        // 1. AOF 没有开启，那么当 rename 时，因为没有其他进程持有对 AOF 文件的引用，会删除原文件，导致阻塞
        // 2. AOF 已经开启，则 redis 服务持有对原 AOF 文件的引用，所以 rename 并不会导致删除原文件，只有当 close  oldfd 时候才会导致删除
        // 如果 redis 并未持有对原 AOF 文件的引用，打开文件增加文件引用
        if (server.aof_fd == -1) {
             // 不需要检查是否打开成功
             oldfd = open(server.aof_filename,O_RDONLY|O_NONBLOCK);
        } else {
            oldfd = -1; /* We'll set this to the current AOF filedes later. */
        }
				// rename 不会导致原 AOF 文件的删除
        if (rename(tmpfile,server.aof_filename) == -1) {
            redisLog(REDIS_WARNING,
                "Error trying to rename the temporary AOF file: %s", strerror(errno));
            close(newfd);
            if (oldfd != -1) close(oldfd);
            goto cleanup;
        }
				
        if (server.aof_fd == -1) {
            // 没有开启 AOF 的话，我们需要 close newfd，不需要担心这个会导致删除
            close(newfd);
        } else {
            // 设定新的 aof_fd
            oldfd = server.aof_fd;
            server.aof_fd = newfd;
            // 因为前面进行了 AOF 重写缓存追加，所以这里立即 fsync 一次
            if (server.aof_fsync == AOF_FSYNC_ALWAYS)
                aof_fsync(newfd);
            else if (server.aof_fsync == AOF_FSYNC_EVERYSEC)
                aof_background_fsync(newfd);
            // 强制引发 SELECT
            server.aof_selected_db = -1; /* Make sure SELECT is re-issued */
            // 更新 AOF 文件的大小
            aofUpdateCurrentSize();
            // 记录前一次重写时的大小
            server.aof_rewrite_base_size = server.aof_current_size;
						// aof_buf 内的数据已经没有作用了，释放 aof_buf
            sdsfree(server.aof_buf);
            server.aof_buf = sdsempty();
        }

        server.aof_lastbgrewrite_status = REDIS_OK;
        redisLog(REDIS_NOTICE, "Background AOF rewrite finished successfully");
				// 更新 aof_state 为 REDIS_AOF_ON （仅发生在第一次）
        if (server.aof_state == REDIS_AOF_WAIT_REWRITE)
            server.aof_state = REDIS_AOF_ON;
				// 在后台线程 close 原 AOF 文件
        if (oldfd != -1) bioCreateBackgroundJob(REDIS_BIO_CLOSE_FILE,(void*)(long)oldfd,NULL,NULL);
        redisLog(REDIS_VERBOSE,
            "Background AOF rewrite signal handler took %lldus", ustime()-now);

    } else if (!bysignal && exitcode != 0) {
        // BGREWRITEAOF 重写出错
        server.aof_lastbgrewrite_status = REDIS_ERR;
        redisLog(REDIS_WARNING,
            "Background AOF rewrite terminated with error");
    } else {
        // 子进程因为接受到信号而退出
        server.aof_lastbgrewrite_status = REDIS_ERR;
        redisLog(REDIS_WARNING,
            "Background AOF rewrite terminated by signal %d", bysignal);
    }

cleanup:
    // 清空 AOF 缓冲区
    aofRewriteBufferReset();
    // 移除临时文件，进行到这里可能临时文件已经不存在了，所以后面的 remove 函数中不需要检查错误
    aofRemoveTempFile(server.aof_child_pid);
    // 重置默认属性
    server.aof_child_pid = -1;
    server.aof_rewrite_time_last = time(NULL)-server.aof_rewrite_time_start;
    server.aof_rewrite_time_start = -1;
    if (server.aof_state == REDIS_AOF_WAIT_REWRITE)
        server.aof_rewrite_scheduled = 1;
}

void aofRemoveTempFile(pid_t childpid) {
    char tmpfile[256];
    snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) childpid);
    unlink(tmpfile);
}

启动 BGREWRITEAOF 以后，redis 还会持续的接受客户端请求。当处理后续的写请求时，需要将这些命令的 AOF 编码数据写入到 AOF rewrite buffer 中，即 AOF rewrite buffer 中存储的是自上次 AOF rewrite 开始以后的所有增量写操作。

关于 close AOF 文件时候的优化也值得学习，尽量避免在工作线程中执行阻塞操作的操作。

command

void bgrewriteaofCommand(redisClient *c) {
    if (server.aof_child_pid != -1) {
         // 不能重复运行 BGREWRITEAOF
        addReplyError(c,"Background append only file rewriting already in progress");
    } else if (server.rdb_child_pid != -1) {
      	// 如果正在执行 BGSAVE ，那么预定 BGREWRITEAOF
    		// 等 BGSAVE 完成之后， BGREWRITEAOF 就会开始执行
        server.aof_rewrite_scheduled = 1;
        addReplyStatus(c,"Background append only file rewriting scheduled");
    } else if (rewriteAppendOnlyFileBackground() == REDIS_OK) {
      	// 执行 BGREWRITEAOF
        addReplyStatus(c,"Background append only file rewriting started");
    } else {
        addReply(c,shared.err);
    }
}

总结

AOF 是 redis 提供的另一种数据持久化方案，其将 redis 服务处理的写请求编码后写入到 AOF 文件，启动时候加载 AOF 文件 replay 即可重建数据库
AOF 相比 RDB 的粒度更细，通过配置不同的 sync 策略，redis 提供不同的数据持久化保证。但是需要注意的是，即使选用性能最差的 always，redis 还是不具有 100% 的数据持久性，因为其 AOF 写入发生在命令处理之后
AOF 和 rdb 一样，为了防止阻塞 redis，将 close 操作放到了后台线程
AOF rewrite 可以对 AOF 文件进行瘦身，防止 AOF 文件不断膨胀

maohuazhu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
redis 源码系列（15）：快照 + 增量记录 --- AOF

在介绍 rdb 的文章中，我们提到 rdb 并不能完美的解决 redis 持久化的问题。因为其只是 redis 数据库的某一时刻的快照，而且因为 rdb 的 dump 过程往往会消耗大量的服务器资源，所以一般都是在业务低峰期进行，而且不会很频繁，一般都是以天为单位来进行。redis 在 dump 两次 rdb 之间，可能会丢失大量的数据。所以 redis 提供了另一种持久化手段，即 append...
复制链接

扫一扫