redis.conf之save配置项解读

配置示例：

save 900 1

save 300 10

save 60 3600

 

配置解读：

1) “save 900 1”表示如果900秒内至少1个key发生变化（新增、修改和删除），则重写rdb文件；

2) “save 300 10”表示如果每300秒内至少10个key发生变化（新增、修改和删除），则重写rdb文件；

3) “save 60 3600”表示如果每60秒内至少10000个key发生变化（新增、修改和删除），则重写rdb文件。

 

作用：

控制什么时候生成rdb文件（快照，也可叫Checkpoint，即检查点）。

 

进程启动的时候，会将每一行save读进到类型为struct saveparam的数组中。这个没有排序，依在redis.conf中的先后顺序。在检查时，只要满足就不会再检查下一条规则。

 

配置策略：

如果同时开启了aof，则可考虑将save的参数调大一点，以减少写rdb带来的压力。实际上如果开启了aof，redis在启动时只会读取aof文件，而不会读取rdb文件：

// Function called at startup to load RDB or AOF file in memory.

void loadDataFromDisk(void) {    

    if (server.aof_state == AOF_ON) {      

        // 允许空的aof文件，

        // 如果读取aof文件出错，则调用exit(1)直接退出进程

        if (loadAppendOnlyFile(server.aof_filename) == C_OK)

            serverLog(LL_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);

    } else {

         if (rdbLoad(server.rdb_filename,&rsi) == C_OK) {

    }

}

 

// #define AOF_OFF 0             /* AOF is off */

// #define AOF_ON 1              /* AOF is on */

void loadServerConfigFromString(char *config) {

    。。。。。。

    } else if (!strcasecmp(argv[0],"appendonly") && argc == 2) {

        int yes;

        if ((yes = yesnotoi(argv[1])) == -1) {

            err = "argument must be 'yes' or 'no'"; goto loaderr;

        }

         server.aof_state = yes ? AOF_ON : AOF_OFF;

    }

    。。。。。。

}

 

int yesnotoi(char *s) {

    if (!strcasecmp(s,"yes")) return 1;

    else if (!strcasecmp(s,"no")) return 0;

    else return -1;

}

 

调用顺序：

main()/server.c ->

aeMain()/ae.c -> while (!stop) { aeProcessEvents()/ae.c } ->

serverCron()/server.c -> rdbSaveBackground()/server.c

 

注：

aeProcessEvents可看作是个epoll_wait调用，在Linux上实际正是epoll_wait调用，而在Solaris上则是port_getn调用。

 

相关源代码：

int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {

    。。。。。。

    // Check if a background saving or AOF rewrite in progress terminated.

    // 如果已有rdb和aof进程，检查进程是否已退出。

    // 如果已退出，则会善后处理，否则什么也不做，等待下一次循环时再次检查

    if (server.rdb_child_pid != -1 ||

        server.aof_child_pid != -1 ||

         ldbPendingChildren()) {

        int statloc;

        pid_t pid;

        if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {

            int exitcode = WEXITSTATUS(statloc);

            。。。。。。

        }

    } else {

        // If there is not a background saving/rewrite

        // in progress check if we have to save/rewrite now.

        // 按在redis.conf中定义的顺序依次遍历每一行配置项

        // 最终是否进行写rdb操作（即生成快照文件），不仅由redis.conf

        // 中的配置项决定，还要看上一次操作的结果和状态。

        for (j = 0; j < server.saveparamslen; j++) {

            struct saveparam *sp = server.saveparams+j;

            // Save if we reached the given amount of changes,

            // the given amount of seconds, and if the latest bgsave was

            // successful or if, in case of an error, at least

            // CONFIG_BGSAVE_RETRY_DELAY seconds already elapsed.

            // CONFIG_BGSAVE_RETRY_DELAY(5): Wait a few secs before trying again.

            if (server.dirty >= sp->changes &&

                server.unixtime-server.lastsave > sp->seconds &&

                (server.unixtime-server.lastbgsave_try>CONFIG_BGSAVE_RETRY_DELAY ||

                 server.lastbgsave_status == C_OK)) {

                serverLog(LL_NOTICE,"%d changes in %d seconds. Saving...",

                    sp->changes, (int)sp->seconds);

                rdbSaveInfo rsi, *rsiptr;

                rsiptr = rdbPopulateSaveInfo(&rsi);

                rdbSaveBackground(server.rdb_filename,rsiptr);

                break; // 遇到一条满足的即结束处理，因为已没有必要判断是否满足下一条配置规则

            }

        }

    }

    。。。。。。     

}

 

// rdb.c

int rdbSaveBackground(char *filename, rdbSaveInfo *rsi) {

    。。。。。。

    server.lastbgsave_try = time(NULL);

    。。。。。。

    // 创建写rdb的子进程

    if ((childpid = fork()) == 0) {

        redisSetProcTitle("redis-rdb-bgsave");

        retval = rdbSave(filename,rsi);

    }

    。。。。。。

}

 

/* Save the DB on disk. Return C_ERR on error, C_OK on success. */

// rdb.c

// rdbSave调用rdbSaveRio将数据写入到rdb文件中

int rdbSave(char *filename, rdbSaveInfo *rsi) {

    。。。。。。

    // 写rdb文件

    if (rdbSaveRio(&rdb,&error,RDB_SAVE_NONE,rsi) == C_ERR) {

        errno = error;

        goto werr;

    }

    。。。。。。

    serverLog(LL_NOTICE,"DB saved on disk");

    server.dirty = 0;

    server.lastsave = time(NULL);

    server.lastbgsave_status = C_OK;

    return C_OK;

}

 

/* Produces a dump of the database in RDB format sending it to the specified

 * Redis I/O channel. On success C_OK is returned, otherwise C_ERR

 * is returned and part of the output, or all the output, can be

 * missing because of I/O errors.

 *

 * When the function returns C_ERR and if 'error' is not NULL, the

 * integer pointed by 'error' is set to the value of errno just after the I/O

 * error. */

int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {

    for (j = 0; j < server.dbnum; j++) {

        。。。。。。

        // Iterate this DB writing every entry

        while((de = dictNext(di)) != NULL) {

            。。。。。。

            // 将一对对KV写入到rdb文件

            if (rdbSaveKeyValuePair(rdb,&key,o,expire) == -1) goto werr;            

            。。。。。。

        }

    }

    。。。。。。

werr:

    if (error) *error = errno;

    if (di) dictReleaseIterator(di);

    return C_ERR;

}

 

// 以SADD命令为例，所有写操作，均会修改dirty 的值

void saddCommand(client *c) {

    。。。。。。

    for (j = 2; j < c->argc; j++) {

        if (setTypeAdd(set,c->argv[j]->ptr)) added++;

    }

    。。。。。。

    server.dirty += added;

    addReplyLongLong(c,added);

}