aofUpdateCurrentSize() {  
1.      redis_stat sb;  
2.   
3.      (redis_fstat(server.aof_fd,&sb) == -1) {  
4.         redisLog(REDIS_WARNING,,  
5.             strerror(errno));  
6.     }  {  
7.         server.aof_current_size = sb.st_size;  
8.     }  
9. }  

redis_fstat是作者对Linux中fstat64函数的重命名，该还是就是获取文件相关的参数信息，具体可以Google之，sb.st_size就是当前AOF文件的大小。这里需要知道server.aof_fd即AOF文件描述符，该参数的初始化在initServer()函数中

<div class="dp-Highlighter bg_cpp">
<div class="bar">
<div class="tools">
[cpp] <a class="ViewSource" title="view plain" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;view plain<a class="CopyToClipboard" title="copy" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;copy<a class="PrintSource" title="print" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;print<a class="About" title="?" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;?<a title="在CODE上查看代码片" href="https://code.csdn.net/snippets/152074" target="_blank">

<img src="https://code.csdn.net/assets/CODE_ico.png" alt="在CODE上查看代码片" width="12" height="12">

<img src="https://code.csdn.net/assets/ico_fork.svg" alt="派生到我的代码片" width="12" height="12">

  
1.      (server.aof_state == REDIS_AOF_ON) {  
2.         server.aof_fd = open(server.aof_filename,O_WRONLY|O_APPEND|O_CREAT,0644);  
3.          (server.aof_fd == -1) {  
4.             redisLog(REDIS_WARNING, ,strerror(errno));  
5.             exit(1);  
6.         }  
7.     }  

至此，Redis Server启动加载硬盘中AOF文件数据的操作就成功结束了。

Server数据库产生新数据如何持久化到硬盘

<div class="dp-highlighter bg_cpp">
<div class="bar">
<div class="tools">
[cpp] <a class="ViewSource" title="view plain" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;view plain<a class="CopyToClipboard" title="copy" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;copy<a class="PrintSource" title="print" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;print<a class="About" title="?" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;?<a title="在CODE上查看代码片" href="https://code.csdn.net/snippets/152074" target="_blank">

<img src="https://code.csdn.net/assets/CODE_ico.png" alt="在CODE上查看代码片" width="12" height="12">

<img src="https://code.csdn.net/assets/ico_fork.svg" alt="派生到我的代码片" width="12" height="12">

 
1.  
2.  
3.  
4.  
5.  
6.  
7.   
8.  propagate( redisCommand *cmd,  dbid, robj **argv,  argc,  
9.                 flags)  
10. {  
11.     文件中  
12.      (server.aof_state != REDIS_AOF_OFF && flags & REDIS_PROPAGATE_AOF)  
13.         FeedAppendOnlyFile(cmd,dbid,argv,argc);  
14.      (flags & REDIS_PROPAGATE_REPL)  
15.         replicationFeedSlaves(server.slaves,argc);  
16. }  

Highlighter bg_cpp">

[cpp] 

 

修改了数据，先将更新的数据写到server.aof_buf中  
1.  FeedAppendOnlyFile( redisCommand *cmd,  dictid,  argc) {  
2.     sds buf = sdsempty();  
3.     robj *tmpargv[3];  
4.   
5.      
6.   
7.     数据库  
8.      (dictid != server.aof_selected_db) {  
9.          seldb[64];  
10.   
11.         snprintf(seldb,(seldb),,dictid);  
12.         buf = sdscatprintf(buf,,  
13.             (unsigned )strlen(seldb),seldb);  
14.         server.aof_selected_db = dictid;  
15.     }  
16.   
17.       
18.      (cmd->proc == expireCommand || cmd->proc == pexpireCommand ||  
19.         cmd->proc == expireatCommand) {  
20.           
21.         buf = catAppendOnlyExpireAtCommand(buf,cmd,argv[1],argv[2]);  
22.     }  
23.       (cmd->proc == setexCommand || cmd->proc == psetexCommand) {  
24.           
25.         tmpargv[0] = createStringObject(,3);  
26.         tmpargv[1] = argv[1];  
27.         tmpargv[2] = argv[3];  
28.         buf = catAppendOnlyGenericCommand(buf,3,tmpargv);  
29.         decrRefCount(tmpargv[0]);  
30.         buf = catAppendOnlyExpireAtCommand(buf,argv[2]);  
31.     }  {  
32.          
33.  
34.   
35.         buf = catAppendOnlyGenericCommand(buf,argc,argv);  
36.     }  
37.   
38.      
39.  
40.   
41.     文件中，并且根据情况fsync刷新到硬盘  
42.      (server.aof_state == REDIS_AOF_ON)  
43.         server.aof_buf = sdscatlen(server.aof_buf,buf,sdslen(buf));  
44.   
45.      
46.  
47.  
48.   
49.     文件(已经开始rewrite)，  
50.       
51.     文件末尾，保证数据不丢失  
52.     数据库中的数据，  
53.     文件，但是此时客户端执行指令又将该值修改了，因此造成了差异  
54.      (server.aof_child_pid != -1)  
55.         aofRewriteBufferAppend((unsigned *)buf,sdslen(buf));  
56.      
57. 文件打开的时候，会不断将这份数据写入到AOF文件中。 
58. 用户主动触发了写AOF文件的命令时，比如 config set appendonly yes命令 
59. 后台进程,也就是当时的数据快照，然后将数据写入到一个临时文件中去。 
60. 后台进程完成AOF临时文件写后，serverCron定时任务 
61. 退出动作，然后就会调用backgroundRewriteDoneHandler进而调用aofRewriteBufferWrite函数， 
62. 文件中，然后再unlink替换正常的AOF文件。 
63.  
64.   
65.   
66.     sdsfree(buf);  
67. }  

Server在每次事件循环之前会调用一次beforeSleep函数，下面看看这个函数做了什么工作？

<div class="dp-Highlighter bg_cpp">
<div class="bar">
<div class="tools">
[cpp] <a class="ViewSource" title="view plain" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;view plain<a class="CopyToClipboard" title="copy" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;copy<a class="PrintSource" title="print" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;print<a class="About" title="?" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;?<a title="在CODE上查看代码片" href="https://code.csdn.net/snippets/152074" target="_blank">

<img src="https://code.csdn.net/assets/CODE_ico.png" alt="在CODE上查看代码片" width="12" height="12">

<img src="https://code.csdn.net/assets/ico_fork.svg" alt="派生到我的代码片" width="12" height="12">

 
1.  
2.   
3.  beforeSleep( aeEventLoop *eventLoop) {  
4.     REDIS_NOTUSED(eventLoop);  
5.     listNode *ln;  
6.     redisClient *c;  
7.   
8.      
9.   
10.      (server.active_expire_enabled && server.masterhost == NULL)  
11.         activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);  
12.   
13.       
14.      (listLength(server.unblocked_clients)) {  
15.         ln = listFirst(server.unblocked_clients);  
16.         redisAssert(ln != NULL);  
17.         c = ln->value;  
18.         listDelNode(server.unblocked_clients,ln);  
19.         c->flags &= ~REDIS_UNBLOCKED;  
20.   
21.           
22.           
23.          (c->querybuf && sdslen(c->querybuf) > 0) {  
24.             server.current_client = c;  
25.             processInputBuffer(c);  
26.             server.current_client = NULL;  
27.         }  
28.     }  
29.   
30.       
31.     文件中并fsync到硬盘上  
32.     flushAppendOnlyFile(0);  
33. }  

通过上面的代码及注释可以发现，beforeSleep函数做了三件事：1、处理过期键，2、处理阻塞期间的客户端请求，3、将server.aof_buf中的数据追加到AOF文件中并fsync刷新到硬盘上，flushAppendOnlyFile函数给定了一个参数force，表示是否强制写入AOF文件，0表示非强制即支持延迟写，1表示强制写入。

<div class="dp-Highlighter bg_cpp">
<div class="bar">
<div class="tools">
[cpp] <a class="ViewSource" title="view plain" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;view plain<a class="CopyToClipboard" title="copy" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;copy<a class="PrintSource" title="print" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;print<a class="About" title="?" href="http://blog.csdn.net/acceptedxukai/article/details/18136903"&gt;?<a title="在CODE上查看代码片" href="https://code.csdn.net/snippets/152074" target="_blank">

<img src="https://code.csdn.net/assets/CODE_ico.png" alt="在CODE上查看代码片" width="12" height="12">

<img src="https://code.csdn.net/assets/ico_fork.svg" alt="派生到我的代码片" width="12" height="12">

 flushAppendOnlyFile( force) {  
1.     ssize_t nwritten;  
2.      sync_in_progress = 0;  
3.      (sdslen(server.aof_buf) == 0) ;  
4.     后台正在等待执行的 fsync 数量  
5.      (server.aof_fsync == AOF_FSYNC_EVERYSEC)  
6.         sync_in_progress = bioPendingJobsOfType(REDIS_BIO_AOF_FSYNC) != 0;  
7.   
8.       
9.      (server.aof_fsync == AOF_FSYNC_EVERYSEC && !force) {  
10.          
11.  
12.   
13.           
14.          (sync_in_progress) {  
15.               
16.              (server.aof_flush_postponed_start == 0) {  
17.                 IoUs write postponinig, remember that we are 
18.   
19.                 server.aof_flush_postponed_start = server.unixtime;  
20.                 ;  
21.             }   (server.unixtime - server.aof_flush_postponed_start < 2) {  
22.                   
23.                  
24.   
25.                 ;  
26.             }  
27.              
28.   
29.             server.aof_delayed_fsync++;  
30.             redisLog(REDIS_NOTICE,);  
31.         }  
32.     }  
33.      
34.   
35.     server.aof_flush_postponed_start = 0;  
36.   
37.      
38.  
39.  
40.  
41.   
42.     文件，如果一切幸运的话，写入会原子性地完成  
43.     nwritten = write(server.aof_fd,server.aof_buf,sdslen(server.aof_buf));  
44.      (nwritten != ()sdslen(server.aof_buf)) {  
45.          
46.  
47.   
48.          (nwritten == -1) {  
49.             redisLog(REDIS_WARNING,,strerror(errno));  
50.         }  {  
51.             redisLog(REDIS_WARNING,  
52.                                      
53.                                    ,  
54.                                    strerror(errno),  
55.                                    ()nwritten,  
56.                                    ()sdslen(server.aof_buf));  
57.   
58.              (ftruncate(server.aof_fd, server.aof_current_size) == -1) {  
59.                 redisLog(REDIS_WARNING,   
60.                            
61.                            
62.                          , strerror(errno));  
63.             }  
64.         }  
65.         exit(1);  
66.     }  
67.     server.aof_current_size += nwritten;  
68.   
69.      
70.   
71.       
72.      ((sdslen(server.aof_buf)+sdsavail(server.aof_buf)) < 4000) {  
73.         sdsclear(server.aof_buf);  
74.     }  {  
75.         sdsfree(server.aof_buf);  
76.         server.aof_buf = sdsempty();  
77.     }  
78.   
79.      
80.   
81.     不支持fsync并且aof rdb子进程正在运行，那么直接返回，  
82.     文件中，只是没有刷新到硬盘  
83.      (server.aof_no_fsync_on_rewrite &&  
84.         (server.aof_child_pid != -1 || server.rdb_child_pid != -1))  
85.             ;  
86.   
87.       
88.      (server.aof_fsync == AOF_FSYNC_ALWAYS) {  
89.          
90. Metadata. */  
91.         aof_fsync(server.aof_fd);   
92.         server.aof_last_fsync = server.unixtime;  
93.     }   ((server.aof_fsync == AOF_FSYNC_EVERYSEC &&  
94.                 server.unixtime > server.aof_last_fsync)) {  
95.          (!sync_in_progress) aof_background_fsync(server.aof_fd);后台线程进行fsync  
96.         server.aof_last_fsync = server.unixtime;  
97.     }  
98. }  

上述代码中请关注server.aof_fsync参数，即设置Redis fsync AOF文件到硬盘的策略，如果设置为AOF_FSYNC_ALWAYS，那么直接在主进程中fsync，如果设置为AOF_FSYNC_EVERYSEC，那么放入后台线程中fsync，后台线程的代码在bio.c中。

小结

感谢此篇博客给我在理解Redis AOF数据持久化方面的巨大帮助，

本人Redis-2.8.2的源码注释已经放到Github中，有需要的读者可以下载，我也会在后续的时间中更新，

接着上一篇文章，本文将介绍Redis是如何实现AOF rewrite的。

转载请注明，文章出自

AOF rewrite的触发机制

如果Redis只是将客户端修改数据库的指令重现存储在AOF文件中，那么AOF文件的大小会不断的增加，因为AOF文件只是简单的重现存储了客户端的指令，而并没有进行合并。对于该问题最简单的处理方式，即当AOF文件满足一定条件时就对AOF进行rewrite，rewrite是根据当前内存数据库中的数据进行遍历写到一个临时的AOF文件，待写完后替换掉原来的AOF文件即可。

Redis触发AOF rewrite机制有三种：

1、Redis Server接收到客户端发送的BGREWRITEAOF指令请求，如果当前AOF/RDB数据持久化没有在执行，那么执行，反之，等当前AOF/RDB数据持久化结束后执行AOF rewrite

2、在Redis配置文件redis.conf中，用户设置了auto-aof-rewrite-percentage和auto-aof-rewrite-min-size参数，并且当前AOF文件大小server.aof_current_size大于auto-aof-rewrite-min-size(server.aof_rewrite_min_size)，同时AOF文件大小的增长率大于auto-aof-rewrite-percentage(server.aof_rewrite_perc)时，会自动触发AOF rewrite

3、用户设置“config set appendonly yes”开启AOF的时，调用startAppendOnly函数会触发rewrite

下面分别介绍上述三种机制的处理.

接收到BGREWRITEAOF指令

[cpp] 

 

> bgrewriteaofCommand(redisClient *c) {  
1.       
2.      (server.aof_child_pid != -1) {  
3.         addReplyError(c,);  
4.     }   (server.rdb_child_pid != -1) {  
5.           
6.         后执行AOF rewrite  
7.         server.aof_rewrite_scheduled = 1;  
8.         addReplyStatus(c,);  
9.     }   (rewriteAppendOnlyFileBackground() == REDIS_OK) {  
10.           
11.         addReplyStatus(c,);  
12.     }  {  
13.         addReply(c,shared.err);  
14.     }  
15. }  

Highlighter bg_cpp">

[cpp] 

 

 
1.   
2.     用户执行 BGREWRITEAOF 命令的话，在后台开始 AOF 重写  
3.     用户执行BGREWRITEAOF命令时，如果RDB文件正在写，那么将server.aof_rewrite_scheduled标记为1  
4.     文件写完后开启AOF rewrite  
5.      (server.rdb_child_pid == -1 && server.aof_child_pid == -1 &&  
6.         server.aof_rewrite_scheduled)  
7.     {  
8.         rewriteAppendOnlyFileBackground();  
9.     }  

Server自动对AOF进行rewrite

[cpp] 

 

  
1.          文件  
2.           (server.rdb_child_pid == -1 &&  
3.              server.aof_child_pid == -1 &&  
4.              server.aof_rewrite_perc &&  
5.              server.aof_current_size > server.aof_rewrite_min_size)  
6.          {  
7.               base = server.aof_rewrite_base_size ?  
8.                             server.aof_rewrite_base_size : 1;  
9.               growth = (server.aof_current_size*100/base) - 100;  
10.              (growth >= server.aof_rewrite_perc) {  
11.                 redisLog(REDIS_NOTICE,,growth);  
12.                 rewriteAppendOnlyFileBackground();  
13.             }  
14.          }  

config set appendonly yes

[cpp] 

 

 (!strcasecmp(c->argv[2]->ptr,)) {  
1.      enable = yesnotoi(o->ptr);  
2.   
3.      (enable == -1)  badfmt;  
4.      (enable == 0 && server.aof_state != REDIS_AOF_OFF) {关闭AOF  
5.         stopAppendOnly();  
6.     }   (enable && server.aof_state == REDIS_AOF_OFF) {  
7.          (startAppendOnly() == REDIS_ERR) {  
8.             addReplyError(c,  
9.                 );  
10.             ;  
11.         }  
12.     }  
13. }  

Highlighter bg_cpp">

[cpp] 

 

Redis AOF rewrite机制的实现

[cpp] 

 

 rewriteAppendOnlyFileBackground() {  
1.     pid_t childpid;  
2.       start;  
3.   
4.     后台重写正在执行  
5.      (server.aof_child_pid != -1)  REDIS_ERR;  
6.     start = ustime();  
7.      ((childpid = fork()) == 0) {  
8.          tmpfile[256];  
9.   
10.           
11.         closeListeningSockets(0);  
12.         redisSetProcTitle();  
13.         snprintf(tmpfile,256,, () getpid());  
14.          (rewriteAppendOnlyFile(tmpfile) == REDIS_OK) {  
15.              private_dirty = zmalloc_get_private_dirty();  
16.   
17.              (private_dirty) {  
18.                 redisLog(REDIS_NOTICE,  
19.                     ,  
20.                     private_dirty/(1024*1024));  
21.             }  
22.             exitFromChild(0);  
23.         }  {  
24.             exitFromChild(1);  
25.         }  
26.     }  {  
27.           
28.         server.stat_fork_time = ustime()-start;  
29.          (childpid == -1) {  
30.             redisLog(REDIS_WARNING,  
31.                 ,  
32.                 strerror(errno));  
33.              REDIS_ERR;  
34.         }  
35.         redisLog(REDIS_NOTICE,  
36.             ,childpid);  
37.         server.aof_rewrite_scheduled = 0;  
38.         server.aof_rewrite_time_start = time(NULL);  
39.         server.aof_child_pid = childpid;  
40.         updateDictResizePolicy();  
41.          
42. FeedAppendOnlyFile() to issue a SELECT command, so the differences 
43.  
44.   
45.         server.aof_selected_db = -1;  
46.         replicationScriptCacheFlush();  
47.          REDIS_OK;  
48.     }  
49.      REDIS_OK;   
50. }  

接下来介绍rewriteAppendOnlyFile函数，该函数的主要工作为：遍历所有数据库中的数据，将其写入到临时文件temp-rewriteaof-%d.aof中，写入函数定义在rio.c中，比较简单，然后将数据刷新到硬盘中，然后将文件名rename为其调用者给定的临时文件名，注意仔细看代码，这里并没有修改为正式的AOF文件名。

Highlighter bg_cpp">

[cpp] 

 

 rewriteAppendOnlyFile( *filename) {  
1.     dictIterator *di = NULL;  
2.     dictEntry *de;  
3.     rio aof;  
4.      *fp;  
5.      tmpfile[256];  
6.      j;  
7.       now = mstime();  
8.   
9.      
10.   
11.     snprintf(tmpfile,, () getpid());  
12.     fp = fopen(tmpfile,);  
13.      (!fp) {  
14.         redisLog(REDIS_WARNING, opening the temp file for AOF rewrite in rewriteAppendOnlyFile(): %s", strerror(errno));  
15.          REDIS_ERR;  
16.     }  
17.   
18.     rioInitWithFile(&aof,fp); 函数，rio.c  
19.     io.file.autosync = bytes;每32M刷新一次  
20.      (server.aof_rewrite_incremental_fsync)  
21.         rioSetAutoSync(&aof,REDIS_AOF_AUTOSYNC_BYTES);  
22.      (j = 0; j < server.dbnum; j++) {数据库  
23.          selectcmd[] = ;  
24.         redisDb *db = server.db+j;  
25.         dict *d = db->dict;  
26.          (dictSize(d) == 0) ;  
27.         di = dictGetSafeIterator(d);  
28.          (!di) {  
29.             fclose(fp);  
30.              REDIS_ERR;  
31.         }  
32.   
33.           
34.          (rioWrite(&aof,selectcmd,(selectcmd)-1) == 0)  werr;  
35.          (rioWriteBulkLongLong(&aof,j) == 0)  werr;  
36.   
37.           
38.         ((de = dictNext(di)) != NULL) {  
39.             sds keystr;  
40.             robj key, *o;  
41.               expiretime;  
42.   
43.             keystr = dictGetKey(de);  
44.             o = dictGetVal(de);  
45.             initStaticStringObject(key,keystr);  
46.   
47.             expiretime = getExpire(db,&key);  
48.   
49.               
50.              (expiretime != -1 && expiretime < now) ;  
51.   
52.               
53.              (o->type == REDIS_STRING) {  
54.                   
55.                  cmd[]=;  
56.                  (rioWrite(&aof,(cmd)-1) == 0)  werr;  
57.                   
58.                  (rioWriteBulkObject(&aof,&key) == 0)  werr;  
59.                  (rioWriteBulkObject(&aof,o) == 0)  werr;  
60.             }   (o->type == REDIS_LIST) {  
61.                  (rewriteListObject(&aof,&key,o) == 0)  werr;  
62.             }   (o->type == REDIS_SET) {  
63.                  (rewriteSetObject(&aof,o) == 0)  werr;  
64.             }   (o->type == REDIS_ZSET) {  
65.                  (rewriteSortedSetObject(&aof,o) == 0)  werr;  
66.             }   (o->type == REDIS_HASH) {  
67.                  (rewriteHashObject(&aof,o) == 0)  werr;  
68.             }  {  
69.                 redisPanic();  
70.             }  
71.               
72.              (expiretime != -1) {  
73.                  cmd[]=;  
74.                  (rioWrite(&aof,(cmd)-1) == 0)  werr;  
75.                  (rioWriteBulkObject(&aof,&key) == 0)  werr;  
76.                  (rioWriteBulkLongLong(&aof,expiretime) == 0)  werr;  
77.             }  
78.         }  
79.         dictReleaseIterator(di);  
80.     }  
81.   
82.       
83.     fflush(fp);  
84.     aof_fsync(fileno(fp));文件刷新到硬盘  
85.     fclose(fp);  
86.   
87.      
88.   
89.      (rename(tmpfile,filename) == -1) {重命名文件名，注意rename后的文件也是一个临时文件  
90.         redisLog(REDIS_WARNING,, strerror(errno));  
91.         unlink(tmpfile);  
92.          REDIS_ERR;  
93.     }  
94.     redisLog(REDIS_NOTICE,);  
95.      REDIS_OK;  
96.   
97. werr:  
98.     fclose(fp);  
99.     unlink(tmpfile);  
100.     redisLog(REDIS_WARNING,, strerror(errno));  
101.      (di) dictReleaseIterator(di);  
102.      REDIS_ERR;  
103. }  

AOF rewrite工作到这里已经结束一半，上一篇文章提到如果server.aof_state != REDIS_AOF_OFF，那么就会将客户端请求指令修改的数据通过FeedAppendOnlyFile函数追加到AOF文件中，那么此时AOF已经rewrite了，必须要处理此时出现的差异数据，记得在FeedAppendOnlyFile函数中有这么一段代码

Highlighter bg_cpp">

[cpp] 

 

 (server.aof_child_pid != -1)  
1.         aofRewriteBufferAppend((unsigned *)buf,sdslen(buf));  

如果AOF rewrite正在进行，那么就将修改数据的指令字符串存储到server.aof_rewrite_buf_blocks链表中，等待AOF rewrite子进程结束后处理，处理此部分数据的代码在serverCron函数中。需要指出的是wait3函数我不了解，可能下面注释会有点问题。

Highlighter bg_cpp">

[cpp] 

 

  
1. 获取子进程的退出状态，对后续的工作进行处理  
2.  (server.rdb_child_pid != -1 || server.aof_child_pid != -1) {  
3.      statloc;  
4.     pid_t pid;  
5.   
6.      ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {  
7.          exitcode = WEXITSTATUS(statloc);获取退出的状态  
8.          bysignal = 0;  
9.   
10.          (WIFSIGNALED(statloc)) bysignal = WTERMSIG(statloc);  
11.   
12.          (pid == server.rdb_child_pid) {  
13.             backgroundSaveDoneHandler(exitcode,bysignal);  
14.         }   (pid == server.aof_child_pid) {  
15.             backgroundRewriteDoneHandler(exitcode,bysignal);  
16.         }  {  
17.             redisLog(REDIS_WARNING,  
18.                 ,  
19.                 ()pid);  
20.         }  
21.           
22.         updateDictResizePolicy();  
23.     }  
24. }  

对于AOF rewrite期间出现的差异数据，Server通过backgroundSaveDoneHandler函数将server.aof_rewrite_buf_blocks链表中数据追加到新的AOF文件中。

Highlighter bg_cpp">

[cpp] 

 

 
1.   
2.  backgroundRewriteDoneHandler( exitcode,  bysignal) {  
3.      (!bysignal && exitcode == 0) {退出状态正确  
4.          newfd, oldfd;  
5.          tmpfile[256];  
6.           now = ustime();  
7.   
8.         redisLog(REDIS_NOTICE,  
9.             );  
10.   
11.          
12.   
13.         snprintf(tmpfile,  
14.             ()server.aof_child_pid);  
15.         newfd = open(tmpfile,O_WRONLY|O_APPEND);  
16.          (newfd == -1) {  
17.             redisLog(REDIS_WARNING,  
18.                 , strerror(errno));  
19.              cleanup;  
20.         }  
21.           
22.          (aofRewriteBufferWrite(newfd) == -1) {  
23.             redisLog(REDIS_WARNING,  
24.                 , strerror(errno));  
25.             close(newfd);  
26.              cleanup;  
27.         }  
28.   
29.         redisLog(REDIS_NOTICE,  
30.             , aofRewriteBufferSize());  
31.   
32.          
33.  
34.  
35.  
36.  
37.  
38.  
39.  
40.  
41.  
42.  
43.  
44.  
45.  
46.  
47.  
48.  
49.  
50.  
51.  
52.  
53. opening the target file 
54.  
55.  
56.  
57.  
58.   
59.          (server.aof_fd == -1) {  
60.               
61.   
62.               
63.  
64.   
65.              oldfd = open(server.aof_filename,O_RDONLY|O_NONBLOCK);  
66.         }  {  
67.               
68.             oldfd = -1;   
69.         }  
70.   
71.          
72.   
73.         文件改名为正常的AOF文件名。由于当前oldfd已经指向这个之前的正常文件名的文件，  
74.         文件没有指向了，就删除之。  
75.          (rename(tmpfile,server.aof_filename) == -1) {  
76.             redisLog(REDIS_WARNING,  
77.                 , strerror(errno));  
78.             close(newfd);  
79.              (oldfd != -1) close(oldfd);  
80.              cleanup;  
81.         }  
82.         关闭了，那只要处理新文件，直接关闭这个新的文件即可  
83.         文件的最后一个fd了，不会的，  
84.         文件在本函数不会写入数据，因为stopAppendOnly函数会清空aof_rewrite_buf_blocks列表。  
85.          (server.aof_fd == -1) {  
86.              
87.   
88.             close(newfd);  
89.         }  {  
90.               
91.             oldfd = server.aof_fd;  
92.             文件名  
93.             server.aof_fd = newfd;  
94.               
95.              (server.aof_fsync == AOF_FSYNC_ALWAYS)  
96.                 aof_fsync(newfd);  
97.               (server.aof_fsync == AOF_FSYNC_EVERYSEC)  
98.                 aof_background_fsync(newfd);  
99.             server.aof_selected_db = -1;   
100.             aofUpdateCurrentSize();  
101.             server.aof_rewrite_base_size = server.aof_current_size;  
102.   
103.              
104.   
105.               
106.             sdsfree(server.aof_buf);  
107.             server.aof_buf = sdsempty();  
108.         }  
109.   
110.         server.aof_lastbgrewrite_status = REDIS_OK;  
111.   
112.         redisLog(REDIS_NOTICE, );  
113.           
114.           
115.          (server.aof_state == REDIS_AOF_WAIT_REWRITE)  
116.             server.aof_state = REDIS_AOF_ON;  
117.   
118.           
119.         后台线程去关闭这个旧的AOF文件FD，只要CLOSE就行，会自动unlink的，因为上面已经有rename  
120.          (oldfd != -1) bioCreateBackgroundJob(REDIS_BIO_CLOSE_FILE,(*)()oldfd,NULL);  
121.   
122.         redisLog(REDIS_VERBOSE,  
123.             , ustime()-now);  
124.     }   (!bysignal && exitcode != 0) {  
125.         server.aof_lastbgrewrite_status = REDIS_ERR;  
126.   
127.         redisLog(REDIS_WARNING,  
128.             );  
129.     }  {  
130.         server.aof_lastbgrewrite_status = REDIS_ERR;  
131.   
132.         redisLog(REDIS_WARNING,  
133.             , bysignal);  
134.     }  
135.   
136. cleanup:  
137.     aofRewriteBufferReset();  
138.     aofRemoveTempFile(server.aof_child_pid);  
139.     server.aof_child_pid = -1;  
140.     server.aof_rewrite_time_last = time(NULL)-server.aof_rewrite_time_start;  
141.     server.aof_rewrite_time_start = -1;  
142.       
143.      (server.aof_state == REDIS_AOF_WAIT_REWRITE)  
144.         server.aof_rewrite_scheduled = 1;  
145. }  

至此，AOF数据持久化已经全部结束了，剩下的就是一些细节的处理，以及一些Linux库函数的理解，对于rename、unlink、wait3等库函数的深入认识就去问Google吧。

小结

• 上一篇：深入redis内部--初始化服务器下一篇：Redis双机热备方案--转

猜你在找的Redis相关文章

Redis主从复制的基本操作

一，安装： 1.1.将redis压缩包放到 /opt 下。 2.解压 3.进入目录执行 make 4.执行 make in...

作者：前端之家 时间：2021-02-25

关于缓存穿透，缓存击穿，缓存雪崩，热点数据失效问题的解决方案

1.我们使用缓存时的业务流程大概为： 当我们查询一条数据时，先去查询缓存，如果缓存有就直...

作者：前端之家 时间：2021-02-25

redis主从与哨兵

1、redis主从 1.1、redis主从复制过程 - Slave 与 master 建立连接，发送 sync 同步命令 -...

作者：前端之家 时间：2021-02-22

redis集群构建

1、集群的概念 集群是一组相互独立的、通过高速网络互联的计算机，它们构成了一个组，并以...

作者：前端之家 时间：2021-02-22

非关系数据库与redis初体验

1、什么是 NoSQL？ NoSQL(NoSQL = Not Only SQL )，意为反 SQL 运动，是一项全新的数据库革...

作者：前端之家 时间：2021-02-22

redis对象操作方法与命令

一、redis 基础操作 1.0、添加环境变量 echo &amp;quot;export PATH=/opt/redis/bin:$...

作者：前端之家 时间：2021-02-22

redis5.* 手动构建集群

1、集群的概念 集群是一组相互独立的、通过高速网络互联的计算机，它们构成了一个组，并以...

作者：前端之家 时间：2021-02-22

一种简单的redis分布式锁方案

前言 用于分布式程序彼此之间不能同时执行的场景。例如计算程序等。 代码 锁工具类 @Compo...

作者：前端之家 时间：2021-02-16

Redis入门教程（一）

一、NoSQL概述 1、什么是NoSQL NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起...

作者：前端之家 时间：2021-02-16

spingboot使用redis连接池报错

配置如下，增加了连接池相关 redis: host: localhost port: 6379 database: 7 lettuce: po...

作者：前端之家 时间：2021-02-16