Redis之RDB持久化

一、前言

Redis是key-value型的内存数据库，所有的数据都保存在内存中，如果一段断电或者服务器宕机那么数据将会全部丢失，这很显然满足不了很多业务场景的需求，比如我的Redis数据库中存放很多待执行的URL爬取任务，如果在运行过程中服务器突然断电，所有的数据及没有处理的任务都会丢失，因此为了解决这个问题Redis引入了RDB持久化功能，此外Redis还提供另外一种更高级的持久化功能AOF持久化，先来看下RDB持久化的实现机制等。

二、RDB持久化

2.1 RDB文件格式

在介绍持久化过程之前，我们来先看下RDB文件的格式

再看下key_value_pairs部分的结构，RDB文件中的key_value_pairs部分都保存了一个或以上数量的键值对，包括键值对的过期信息等，

2.2 RDB文件的创建与载入

Redis中有两个命令可以生成RDB文件，一个是SAVE，另外一个是BGSAVE

SAVE命令：SAVE命令会阻塞Redis服务器进程，指导RDB文件创建完毕，在这个期间服务器进程不能处理任何来自客户端的命令请求。

BGSAVE命令：BGSAVE命令会从服务器进程中派生出一个子进程，然后由子进程负责创建RDB文件，服务器进程继续处理命令请求

创建RDB文件过程由rdb.c/rdbSave函数完成

/* 后台进行rbd保存操作 */
int rdbSaveBackground(char *filename) {
    pid_t childpid;
    long long start;

    if (server.rdb_child_pid != -1) return REDIS_ERR;
	// 距离上一次成功执行SAVE或者BGSAVE命令之后，服务器对数据库状态进行了多少次修改
    server.dirty_before_bgsave = server.dirty;
    server.lastbgsave_try = time(NULL);
    // 获取当前系统时间
    start = ustime();
    //利用fork()创建子进程用来实现rdb的保存操作
    //此时有2个进程在执行这段函数的代码，在子进行程返回的pid为0,
    //所以会执行下面的代码，在父进程中返回的代码为孩子的pid,不为0，所以执行else分支的代码
    //在父进程中放返回-1代表创建子进程失败
    if ((childpid = fork()) == 0) {
    	//在这个if判断的代码就是在子线程中后执行的操作
        int retval;

        /* Child */
		// 由于子进程会和父进程共享打开的Socket文件描述句柄，所以要在子进程中关闭其
        closeListeningSockets(0);
        redisSetProcTitle("redis-rdb-bgsave");
        //这个就是刚刚说的rdbSave()操作
        // 开始执行save过程
        retval = rdbSave(filename);
        if (retval == REDIS_OK) {
            size_t private_dirty = zmalloc_get_private_dirty();

            if (private_dirty) {
                redisLog(REDIS_NOTICE,
                    "RDB: %zu MB of memory used by copy-on-write",
                    private_dirty/(1024*1024));
            }
        }
        exitFromChild((retval == REDIS_OK) ? 0 : 1);
    } else {
    	//执行父线程的后续操作
        /* Parent */
        server.stat_fork_time = ustime()-start;
        server.stat_fork_rate = (double) zmalloc_used_memory() * 1000000 / server.stat_fork_time / (1024*1024*1024); /* GB per second. */
        latencyAddSampleIfNeeded("fork",server.stat_fork_time/1000);
        if (childpid == -1) {
            server.lastbgsave_status = REDIS_ERR;
            redisLog(REDIS_WARNING,"Can't save in background: fork: %s",
                strerror(errno));
            return REDIS_ERR;
        }
        redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
        server.rdb_save_time_start = time(NULL);
        server.rdb_child_pid = childpid;
        updateDictResizePolicy();
        return REDIS_OK;
    }
    return REDIS_OK; /* unreached */
}

/* 保存rdb数据库的内容到磁盘中 */
int rdbSave(char *filename) {
    dictIterator *di = NULL;
    dictEntry *de;
    char tmpfile[256];
    char magic[10];
    int j;
    long long now = mstime();
    FILE *fp;
    rio rdb;
    uint64_t cksum;

    snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
    fp = fopen(tmpfile,"w");
    if (!fp) {
    	//随时记录错误日志，此时为文件无法打开的时候
        redisLog(REDIS_WARNING, "Failed opening .rdb for saving: %s",
            strerror(errno));
        return REDIS_ERR;
    }

	//初始化rbd和fp的初始操作，据此判断，后面关于rdb的操作都存入到fp这个文件中
	// 使用rio进行健壮的I/O读写，将文件句柄与读缓冲区联系起来
    rioInitWithFile(&rdb,fp);
    if (server.rdb_checksum)
        rdb.update_cksum = rioGenericUpdateChecksum;
    snprintf(magic,sizeof(magic),"REDIS%04d",REDIS_RDB_VERSION);
    if (rdbWriteRaw(&rdb,magic,9) == -1) goto werr;

	//循环服务端下的所有数据库
    for (j = 0; j < server.dbnum; j++) {
    	//获取单个数据库
        redisDb *db = server.db+j;
        dict *d = db->dict;
        if (dictSize(d) == 0) continue;
        di = dictGetSafeIterator(d);
        if (!di) {
            fclose(fp);
            return REDIS_ERR;
        }

        /* Write the SELECT DB opcode */
        if (rdbSaveType(&rdb,REDIS_RDB_OPCODE_SELECTDB) == -1) goto werr;
        if (rdbSaveLen(&rdb,j) == -1) goto werr;

        /* Iterate this DB writing every entry */
        while((de = dictNext(di)) != NULL) {
            sds keystr = dictGetKey(de);
            robj key, *o = dictGetVal(de);
            long long expire;

            initStaticStringObject(key,keystr);
            expire = getExpire(db,&key);
            //将里面的键值存入rdb中
            if (rdbSaveKeyValuePair(&rdb,&key,o,expire,now) == -1) goto werr;
        }
        dictReleaseIterator(di);
    }
    di = NULL; /* So that we don't release it again on error. */

    /* EOF opcode */
    if (rdbSaveType(&rdb,REDIS_RDB_OPCODE_EOF) == -1) goto werr;

    /* CRC64 checksum. It will be zero if checksum computation is disabled, the
     * loading code skips the check in this case. */
    cksum = rdb.cksum;
    memrev64ifbe(&cksum);
    if (rioWrite(&rdb,&cksum,8) == 0) goto werr;

    /* Make sure data will not remain on the OS's output buffers */
    if (fflush(fp) == EOF) goto werr;
    if (fsync(fileno(fp)) == -1) goto werr;
    if (fclose(fp) == EOF) goto werr;

    /* Use RENAME to make sure the DB file is changed atomically only
     * if the generate DB file is ok. */
    if (rename(tmpfile,filename) == -1) {
        redisLog(REDIS_WARNING,"Error moving temp DB file on the final destination: %s", strerror(errno));
        unlink(tmpfile);
        return REDIS_ERR;
    }
    redisLog(REDIS_NOTICE,"DB saved on disk");
    server.dirty = 0;
    server.lastsave = time(NULL);
    server.lastbgsave_status = REDIS_OK;
    return REDIS_OK;

werr:
	//这里又用到了goto处理异常操作的代码
    fclose(fp);
    unlink(tmpfile);
    redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno));
    if (di) dictReleaseIterator(di);
    return REDIS_ERR;
}

在具体的文件写入过程中，作者使用了自己包装的rio包，实现带缓冲、健壮的读写文件，

首先使用rio进行健壮的I/O读写，将文件句柄与读缓冲区联系起来

// 使用rio进行健壮的I/O读写，将文件句柄与读缓冲区联系起来
    rioInitWithFile(&rdb,fp);

/* 根据上面描述的方法，定义了FileRio */
static const rio rioFileIO = {
    rioFileRead,
    rioFileWrite,
    rioFileTell,
    NULL,           /* update_checksum */
    0,              /* current checksum */
    0,              /* bytes read or written */
    0,              /* read/write chunk size */
    { { NULL, 0 } } /* union for io-specific vars */
};

/* 初始化rio中的file变量 */
void rioInitWithFile(rio *r, FILE *fp) {
    *r = rioFileIO;
    r->io.file.fp = fp;
    r->io.file.buffered = 0;
    r->io.file.autosync = 0;
}

最终的实现由rio.h中的rioWrite函数实现带缓冲的读写

static inline size_t rioWrite(rio *r, const void *buf, size_t len) {
    while (len) {
    	//判断当前操作字节长度是否超过最大长度
        size_t bytes_to_write = (r->max_processing_chunk && r->max_processing_chunk < len) ? r->max_processing_chunk : len;
        //写入新的数据时，更新校验和
        if (r->update_cksum) r->update_cksum(r,buf,bytes_to_write);
        //执行写方法
        if (r->write(r,buf,bytes_to_write) == 0)
            return 0;
        buf = (char*)buf + bytes_to_write;
        len -= bytes_to_write;
        //操作字节数增加
        r->processed_bytes += bytes_to_write;
    }
    return 1;
}