Redis數據持久化機制AOF原理分析一

 

Redis數據持久化機制AOF原理分析一

分類： Redis 2014-01-11 14:19  823人閱讀  評論(0)  收藏  舉報

AOF redis

目錄(?)[+]

本文所引用的源碼所有來自Redis2.8.2版本。

Redis AOF數據持久化機制的實現相關代碼是redis.c, redis.h, aof.c, bio.c, rio.c, config.c

在閱讀本文以前請先閱讀Redis數據持久化機制AOF原理分析之配置詳解文章，瞭解AOF相關參數的解析，文章連接

http://blog.csdn.net/acceptedxukai/article/details/18135219

轉載請註明，文章出自http://blog.csdn.net/acceptedxukai/article/details/18136903

下面將介紹AOF數據持久化機制的實現

Server啓動加載AOF文件數據

Server啓動加載AOF文件數據的執行步驟爲:main() -> initServerConfig() -> loadServerConfig() -> initServer() -> loadDataFromDisk()。initServerConfig()主要爲初始化默認的AOF參數配置；loadServerConfig()加載配置文件redis.conf中AOF的參數配置，覆蓋Server的默認AOF參數配置，若是配置appendonly on，那麼AOF數據持久化功能將被激活，server.aof_state參數被設置爲REDIS_AOF_ON；loadDataFromDisk()判斷server.aof_state == REDIS_AOF_ON，結果爲True就調用loadAppendOnlyFile函數加載AOF文件中的數據，加載的方法就是讀取AOF文件中數據，因爲AOF文件中存儲的數據與客戶端發送的請求格式相同徹底符合Redis的通訊協議，所以Server建立僞客戶端fakeClient，將解析後的AOF文件數據像客戶端請求同樣調用各類指令，cmd->proc(fakeClient)，將AOF文件中的數據重現到Redis Server數據庫中。

[cpp]  view plain copy print ?

1. /* Function called at startup to load RDB or AOF file in memory. */  
2. void loadDataFromDisk(void) {  
3.     long long start = ustime();  
4.     if (server.aof_state == REDIS_AOF_ON) {  
5.         if (loadAppendOnlyFile(server.aof_filename) == REDIS_OK)  
6.             redisLog(REDIS_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);  
7.     } else {  
8.         if (rdbLoad(server.rdb_filename) == REDIS_OK) {  
9.             redisLog(REDIS_NOTICE,"DB loaded from disk: %.3f seconds",  
10.                 (float)(ustime()-start)/1000000);  
11.         } else if (errno != ENOENT) {  
12.             redisLog(REDIS_WARNING,"Fatal error loading the DB: %s. Exiting.",strerror(errno));  
13.             exit(1);  
14.         }  
15.     }  
16. }  

Server首先判斷加載AOF文件是由於AOF文件中的數據要比RDB文件中的數據要新。

[cpp]  view plain copy print ?

1. int loadAppendOnlyFile(char *filename) {  
2.     struct redisClient *fakeClient;  
3.     FILE *fp = fopen(filename,"r");  
4.     struct redis_stat sb;  
5.     int old_aof_state = server.aof_state;  
6.     long loops = 0;  
7.   
8.     //redis_fstat就是fstat64函數，經過fileno(fp)獲得文件描述符，獲取文件的狀態存儲於sb中，  
9.     //具體能夠參考stat函數，st_size就是文件的字節數  
10.     if (fp && redis_fstat(fileno(fp),&sb) != -1 && sb.st_size == 0) {  
11.         server.aof_current_size = 0;  
12.         fclose(fp);  
13.         return REDIS_ERR;  
14.     }  
15.   
16.     if (fp == NULL) {//打開文件失敗  
17.         redisLog(REDIS_WARNING,"Fatal error: can't open the append log file for reading: %s",strerror(errno));  
18.         exit(1);  
19.     }  
20.   
21.     /* Temporarily disable AOF, to prevent EXEC from feeding a MULTI 
22.      * to the same file we're about to read. */  
23.     server.aof_state = REDIS_AOF_OFF;  
24.   
25.     fakeClient = createFakeClient(); //創建僞終端  
26.     startLoading(fp); // 定義於 rdb.c ，更新服務器的載入狀態  
27.   
28.     while(1) {  
29.         int argc, j;  
30.         unsigned long len;  
31.         robj **argv;  
32.         char buf[128];  
33.         sds argsds;  
34.         struct redisCommand *cmd;  
35.   
36.         /* Serve the clients from time to time */  
37.         // 有間隔地處理外部請求，ftello()函數獲得文件的當前位置，返回值爲long  
38.         if (!(loops++ % 1000)) {  
39.             loadingProgress(ftello(fp));//保存aof文件讀取的位置，ftellno(fp)獲取文件當前位置  
40.             aeProcessEvents(server.el, AE_FILE_EVENTS|AE_DONT_WAIT);//處理事件  
41.         }  
42.         //按行讀取AOF數據  
43.         if (fgets(buf,sizeof(buf),fp) == NULL) {  
44.             if (feof(fp))//達到文件尾EOF  
45.                 break;  
46.             else  
47.                 goto readerr;  
48.         }  
49.         //讀取AOF文件中的命令，依照Redis的協議處理  
50.         if (buf[0] != '*') goto fmterr;  
51.         argc = atoi(buf+1);//參數個數  
52.         if (argc < 1) goto fmterr;  
53.   
54.         argv = zmalloc(sizeof(robj*)*argc);//參數值  
55.         for (j = 0; j < argc; j++) {  
56.             if (fgets(buf,sizeof(buf),fp) == NULL) goto readerr;  
57.             if (buf[0] != '$') goto fmterr;  
58.             len = strtol(buf+1,NULL,10);//每一個bulk的長度  
59.             argsds = sdsnewlen(NULL,len);//新建一個空sds  
60.             //按照bulk的長度讀取  
61.             if (len && fread(argsds,len,1,fp) == 0) goto fmterr;  
62.             argv[j] = createObject(REDIS_STRING,argsds);  
63.             if (fread(buf,2,1,fp) == 0) goto fmterr; /* discard CRLF 跳過\r\n*/  
64.         }  
65.   
66.         /* Command lookup */  
67.         cmd = lookupCommand(argv[0]->ptr);  
68.         if (!cmd) {  
69.             redisLog(REDIS_WARNING,"Unknown command '%s' reading the append only file", (char*)argv[0]->ptr);  
70.             exit(1);  
71.         }  
72.         /* Run the command in the context of a fake client */  
73.         fakeClient->argc = argc;  
74.         fakeClient->argv = argv;  
75.         cmd->proc(fakeClient);//執行命令  
76.   
77.         /* The fake client should not have a reply */  
78.         redisAssert(fakeClient->bufpos == 0 && listLength(fakeClient->reply) == 0);  
79.         /* The fake client should never get blocked */  
80.         redisAssert((fakeClient->flags & REDIS_BLOCKED) == 0);  
81.   
82.         /* Clean up. Command code may have changed argv/argc so we use the 
83.          * argv/argc of the client instead of the local variables. */  
84.         for (j = 0; j < fakeClient->argc; j++)  
85.             decrRefCount(fakeClient->argv[j]);  
86.         zfree(fakeClient->argv);  
87.     }  
88.   
89.     /* This point can only be reached when EOF is reached without errors. 
90.      * If the client is in the middle of a MULTI/EXEC, log error and quit. */  
91.     if (fakeClient->flags & REDIS_MULTI) goto readerr;  
92.   
93.     fclose(fp);  
94.     freeFakeClient(fakeClient);  
95.     server.aof_state = old_aof_state;  
96.     stopLoading();  
97.     aofUpdateCurrentSize(); //更新server.aof_current_size，AOF文件大小  
98.     server.aof_rewrite_base_size = server.aof_current_size;  
99.     return REDIS_OK;  
100.     …………  
101. }  

在前面一篇關於AOF參數配置的博客遺留了一個問題，server.aof_current_size參數的初始化，下面解決這個疑問。

[cpp]  view plain copy print ?

1. void aofUpdateCurrentSize(void) {  
2.     struct redis_stat sb;  
3.   
4.     if (redis_fstat(server.aof_fd,&sb) == -1) {  
5.         redisLog(REDIS_WARNING,"Unable to obtain the AOF file length. stat: %s",  
6.             strerror(errno));  
7.     } else {  
8.         server.aof_current_size = sb.st_size;  
9.     }  
10. }  

redis_fstat是做者對Linux中fstat64函數的重命名，該仍是就是獲取文件相關的參數信息，具體能夠Google之，sb.st_size就是當前AOF文件的大小。這裏須要知道server.aof_fd即AOF文件描述符，該參數的初始化在initServer()函數中

[cpp]  view plain copy print ?

1. /* Open the AOF file if needed. */  
2.     if (server.aof_state == REDIS_AOF_ON) {  
3.         server.aof_fd = open(server.aof_filename,O_WRONLY|O_APPEND|O_CREAT,0644);  
4.         if (server.aof_fd == -1) {  
5.             redisLog(REDIS_WARNING, "Can't open the append-only file: %s",strerror(errno));  
6.             exit(1);  
7.         }  
8.     }  

至此，Redis Server啓動加載硬盤中AOF文件數據的操做就成功結束了。

Server數據庫產生新數據如何持久化到硬盤

當客戶端執行Set等修改數據庫中字段的指令時就會形成Server數據庫中數據被修改，這些修改的數據應該被實時更新到AOF文件中，而且也要按照必定的fsync機制刷新到硬盤中，保證數據不會丟失。

在上一篇博客中，提到了三種fsync方式:appendfsync always, appendfsync everysec, appendfsync no. 具體體如今server.aof_fsync參數中。

首先看當客戶端請求的指令形成數據被修改，Redis是如何將修改數據的指令添加到server.aof_buf中的。

call() -> propagate() -> feedAppendOnlyFile()，call()函數判斷執行指令後是否形成數據被修改。

feedAppendOnlyFile函數首先會判斷Server是否開啓了AOF，若是開啓AOF，那麼根據Redis通信協議將修改數據的指令重現成請求的字符串，注意在超時設置的處理方式，接着將字符串append到server.aof_buf中便可。該函數最後兩行代碼須要注意，這纔是重點，若是server.aof_child_pid != -1那麼代表此時Server正在重寫rewrite AOF文件，須要將被修改的數據追加到server.aof_rewrite_buf_blocks鏈表中，等待rewrite結束後，追加到AOF文件中。具體見下面代碼的註釋。

[cpp]  view plain copy print ?

1. /* Propagate the specified command (in the context of the specified database id) 
2.  * to AOF and Slaves. 
3.  * 
4.  * flags are an xor between: 
5.  * + REDIS_PROPAGATE_NONE (no propagation of command at all) 
6.  * + REDIS_PROPAGATE_AOF (propagate into the AOF file if is enabled) 
7.  * + REDIS_PROPAGATE_REPL (propagate into the replication link) 
8.  */  
9. void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,  
10.                int flags)  
11. {  
12.     //將cmd指令變更的數據追加到AOF文件中  
13.     if (server.aof_state != REDIS_AOF_OFF && flags & REDIS_PROPAGATE_AOF)  
14.         feedAppendOnlyFile(cmd,dbid,argv,argc);  
15.     if (flags & REDIS_PROPAGATE_REPL)  
16.         replicationFeedSlaves(server.slaves,dbid,argv,argc);  
17. }  

[cpp]  view plain copy print ?

1. //cmd指令修改了數據，先將更新的數據寫到server.aof_buf中  
2. void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) {  
3.     sds buf = sdsempty();  
4.     robj *tmpargv[3];  
5.   
6.     /* The DB this command was targeting is not the same as the last command 
7.      * we appendend. To issue a SELECT command is needed. */  
8.     // 當前 db 不是指定的 aof db，經過建立 SELECT 命令來切換數據庫  
9.     if (dictid != server.aof_selected_db) {  
10.         char seldb[64];  
11.   
12.         snprintf(seldb,sizeof(seldb),"%d",dictid);  
13.         buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%lu\r\n%s\r\n",  
14.             (unsigned long)strlen(seldb),seldb);  
15.         server.aof_selected_db = dictid;  
16.     }  
17.   
18.     // 將 EXPIRE / PEXPIRE / EXPIREAT 命令翻譯爲 PEXPIREAT 命令  
19.     if (cmd->proc == expireCommand || cmd->proc == pexpireCommand ||  
20.         cmd->proc == expireatCommand) {  
21.         /* Translate EXPIRE/PEXPIRE/EXPIREAT into PEXPIREAT */  
22.         buf = catAppendOnlyExpireAtCommand(buf,cmd,argv[1],argv[2]);  
23.     }// 將 SETEX / PSETEX 命令翻譯爲 SET 和 PEXPIREAT 組合命令  
24.     else if (cmd->proc == setexCommand || cmd->proc == psetexCommand) {  
25.         /* Translate SETEX/PSETEX to SET and PEXPIREAT */  
26.         tmpargv[0] = createStringObject("SET",3);  
27.         tmpargv[1] = argv[1];  
28.         tmpargv[2] = argv[3];  
29.         buf = catAppendOnlyGenericCommand(buf,3,tmpargv);  
30.         decrRefCount(tmpargv[0]);  
31.         buf = catAppendOnlyExpireAtCommand(buf,cmd,argv[1],argv[2]);  
32.     } else {//其餘的指令直接追加  
33.         /* All the other commands don't need translation or need the 
34.          * same translation already operated in the command vector 
35.          * for the replication itself. */  
36.         buf = catAppendOnlyGenericCommand(buf,argc,argv);  
37.     }  
38.   
39.     /* Append to the AOF buffer. This will be flushed on disk just before 
40.      * of re-entering the event loop, so before the client will get a 
41.      * positive reply about the operation performed. */  
42.     // 將 buf 追加到服務器的 aof_buf 末尾，在beforeSleep中寫到AOF文件中，而且根據狀況fsync刷新到硬盤  
43.     if (server.aof_state == REDIS_AOF_ON)  
44.         server.aof_buf = sdscatlen(server.aof_buf,buf,sdslen(buf));  
45.   
46.     /* If a background append only file rewriting is in progress we want to 
47.      * accumulate the differences between the child DB and the current one 
48.      * in a buffer, so that when the child process will do its work we 
49.      * can append the differences to the new append only file. */  
50.     //若是server.aof_child_pid不爲1，那就說明有快照進程正在寫數據到臨時文件(已經開始rewrite)，  
51.     //那麼必須先將這段時間接收到的指令更新的數據先暫時存儲起來，等到快照進程完成任務後，  
52.     //將這部分數據寫入到AOF文件末尾，保證數據不丟失  
53.     //解釋爲何須要aof_rewrite_buf_blocks，當server在進行rewrite時即讀取全部數據庫中的數據，  
54.     //有些數據已經寫到新的AOF文件，可是此時客戶端執行指令又將該值修改了，所以形成了差別  
55.     if (server.aof_child_pid != -1)  
56.         aofRewriteBufferAppend((unsigned char*)buf,sdslen(buf));  
57.     /*這裏說一下server.aof_buf和server.aof_rewrite_buf_blocks的區別 
58.       aof_buf是正常狀況下aof文件打開的時候，會不斷將這份數據寫入到AOF文件中。 
59.       aof_rewrite_buf_blocks 是若是用戶主動觸發了寫AOF文件的命令時，好比 config set appendonly yes命令 
60.       那麼redis會fork建立一個後臺進程,也就是當時的數據快照，而後將數據寫入到一個臨時文件中去。 
61.       在此期間發送的命令，咱們須要把它們記錄起來，等後臺進程完成AOF臨時文件寫後，serverCron定時任務 
62.       感知到這個退出動做，而後就會調用backgroundRewriteDoneHandler進而調用aofRewriteBufferWrite函數， 
63.       將aof_rewrite_buf_blocks上面的數據，也就是diff數據寫入到臨時AOF文件中，而後再unlink替換正常的AOF文件。 
64.       所以能夠知道，aof_buf通常狀況下比aof_rewrite_buf_blocks要少， 
65.       但開始的時候可能aof_buf包含一些後者不包含的前面部分數據。*/  
66.   
67.     sdsfree(buf);  
68. }  

Server在每次事件循環以前會調用一次beforeSleep函數，下面看看這個函數作了什麼工做？

[cpp]  view plain copy print ?

1. /* This function gets called every time Redis is entering the 
2.  * main loop of the event driven library, that is, before to sleep 
3.  * for ready file descriptors. */  
4. void beforeSleep(struct aeEventLoop *eventLoop) {  
5.     REDIS_NOTUSED(eventLoop);  
6.     listNode *ln;  
7.     redisClient *c;  
8.   
9.     /* Run a fast expire cycle (the called function will return 
10.      * ASAP if a fast cycle is not needed). */  
11.     if (server.active_expire_enabled && server.masterhost == NULL)  
12.         activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);  
13.   
14.     /* Try to process pending commands for clients that were just unblocked. */  
15.     while (listLength(server.unblocked_clients)) {  
16.         ln = listFirst(server.unblocked_clients);  
17.         redisAssert(ln != NULL);  
18.         c = ln->value;  
19.         listDelNode(server.unblocked_clients,ln);  
20.         c->flags &= ~REDIS_UNBLOCKED;  
21.   
22.         /* Process remaining data in the input buffer. */  
23.         //處理客戶端在阻塞期間接收到的客戶端發送的請求  
24.         if (c->querybuf && sdslen(c->querybuf) > 0) {  
25.             server.current_client = c;  
26.             processInputBuffer(c);  
27.             server.current_client = NULL;  
28.         }  
29.     }  
30.   
31.     /* Write the AOF buffer on disk */  
32.     //將server.aof_buf中的數據追加到AOF文件中並fsync到硬盤上  
33.     flushAppendOnlyFile(0);  
34. }  

經過上面的代碼及註釋能夠發現，beforeSleep函數作了三件事：一、處理過時鍵，二、處理阻塞期間的客戶端請求，三、將server.aof_buf中的數據追加到AOF文件中並fsync刷新到硬盤上，flushAppendOnlyFile函數給定了一個參數force，表示是否強制寫入AOF文件，0表示非強制即支持延遲寫，1表示強制寫入。

[cpp]  view plain copy print ?

1. void flushAppendOnlyFile(int force) {  
2.     ssize_t nwritten;  
3.     int sync_in_progress = 0;  
4.     if (sdslen(server.aof_buf) == 0) return;  
5.     // 返回後臺正在等待執行的 fsync 數量  
6.     if (server.aof_fsync == AOF_FSYNC_EVERYSEC)  
7.         sync_in_progress = bioPendingJobsOfType(REDIS_BIO_AOF_FSYNC) != 0;  
8.   
9.     // AOF 模式爲每秒 fsync ，而且 force 不爲 1 若是能夠的話，推延沖洗  
10.     if (server.aof_fsync == AOF_FSYNC_EVERYSEC && !force) {  
11.         /* With this append fsync policy we do background fsyncing. 
12.          * If the fsync is still in progress we can try to delay 
13.          * the write for a couple of seconds. */  
14.         // 若是 aof_fsync 隊列裏已經有正在等待的任務  
15.         if (sync_in_progress) {  
16.             // 上一次沒有推遲沖洗過，記錄推延的當前時間，而後返回  
17.             if (server.aof_flush_postponed_start == 0) {  
18.                 /* No previous write postponinig, remember that we are 
19.                  * postponing the flush and return. */  
20.                 server.aof_flush_postponed_start = server.unixtime;  
21.                 return;  
22.             } else if (server.unixtime - server.aof_flush_postponed_start < 2) {  
23.                 // 容許在兩秒以內的推延沖洗  
24.                 /* We were already waiting for fsync to finish, but for less 
25.                  * than two seconds this is still ok. Postpone again. */  
26.                 return;  
27.             }  
28.             /* Otherwise fall trough, and go write since we can't wait 
29.              * over two seconds. */  
30.             server.aof_delayed_fsync++;  
31.             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.");  
32.         }  
33.     }  
34.     /* If you are following this code path, then we are going to write so 
35.      * set reset the postponed flush sentinel to zero. */  
36.     server.aof_flush_postponed_start = 0;  
37.   
38.     /* We want to perform a single write. This should be guaranteed atomic 
39.      * at least if the filesystem we are writing is a real physical one. 
40.      * While this will save us against the server being killed I don't think 
41.      * there is much to do about the whole server stopping for power problems 
42.      * or alike */  
43.     // 將 AOF 緩存寫入到文件，若是一切幸運的話，寫入會原子性地完成  
44.     nwritten = write(server.aof_fd,server.aof_buf,sdslen(server.aof_buf));  
45.     if (nwritten != (signed)sdslen(server.aof_buf)) {//出錯  
46.         /* Ooops, we are in troubles. The best thing to do for now is 
47.          * aborting instead of giving the illusion that everything is 
48.          * working as expected. */  
49.         if (nwritten == -1) {  
50.             redisLog(REDIS_WARNING,"Exiting on error writing to the append-only file: %s",strerror(errno));  
51.         } else {  
52.             redisLog(REDIS_WARNING,"Exiting on short write while writing to "  
53.                                    "the append-only file: %s (nwritten=%ld, "  
54.                                    "expected=%ld)",  
55.                                    strerror(errno),  
56.                                    (long)nwritten,  
57.                                    (long)sdslen(server.aof_buf));  
58.   
59.             if (ftruncate(server.aof_fd, server.aof_current_size) == -1) {  
60.                 redisLog(REDIS_WARNING, "Could not remove short write "  
61.                          "from the append-only file.  Redis may refuse "  
62.                          "to load the AOF the next time it starts.  "  
63.                          "ftruncate: %s", strerror(errno));  
64.             }  
65.         }  
66.         exit(1);  
67.     }  
68.     server.aof_current_size += nwritten;  
69.   
70.     /* Re-use AOF buffer when it is small enough. The maximum comes from the 
71.      * arena size of 4k minus some overhead (but is otherwise arbitrary). */  
72.     // 若是 aof 緩存不是太大，那麼重用它，不然，清空 aof 緩存  
73.     if ((sdslen(server.aof_buf)+sdsavail(server.aof_buf)) < 4000) {  
74.         sdsclear(server.aof_buf);  
75.     } else {  
76.         sdsfree(server.aof_buf);  
77.         server.aof_buf = sdsempty();  
78.     }  
79.   
80.     /* Don't fsync if no-appendfsync-on-rewrite is set to yes and there are 
81.      * children doing I/O in the background. */  
82.     //aof rdb子進程運行中不支持fsync而且aof rdb子進程正在運行，那麼直接返回，  
83.     //可是數據已經寫到aof文件中，只是沒有刷新到硬盤  
84.     if (server.aof_no_fsync_on_rewrite &&  
85.         (server.aof_child_pid != -1 || server.rdb_child_pid != -1))  
86.             return;  
87.   
88.     /* Perform the fsync if needed. */  
89.     if (server.aof_fsync == AOF_FSYNC_ALWAYS) {//老是fsync，那麼直接進行fsync  
90.         /* aof_fsync is defined as fdatasync() for Linux in order to avoid 
91.          * flushing metadata. */  
92.         aof_fsync(server.aof_fd); /* Let's try to get this data on the disk */  
93.         server.aof_last_fsync = server.unixtime;  
94.     } else if ((server.aof_fsync == AOF_FSYNC_EVERYSEC &&  
95.                 server.unixtime > server.aof_last_fsync)) {  
96.         if (!sync_in_progress) aof_background_fsync(server.aof_fd);//放到後臺線程進行fsync  
97.         server.aof_last_fsync = server.unixtime;  
98.     }  
99. }  

上述代碼中請關注server.aof_fsync參數，即設置Redis fsync AOF文件到硬盤的策略，若是設置爲AOF_FSYNC_ALWAYS，那麼直接在主進程中fsync，若是設置爲AOF_FSYNC_EVERYSEC，那麼放入後臺線程中fsync，後臺線程的代碼在bio.c中。

小結

文章寫到這，已經解決的了Redis Server啓動加載AOF文件和如何將客戶端請求產生的新的數據追加到AOF文件中，對於追加數據到AOF文件中，根據fsync的配置策略如何將寫入到AOF文件中的新數據刷新到硬盤中，直接在主進程中fsync或是在後臺線程fsync。

至此，AOF數據持久化還剩下如何rewrite AOF，接受客戶端發送的BGREWRITEAOF請求，此部份內容待下篇博客中解析。

感謝此篇博客給我在理解Redis AOF數據持久化方面的巨大幫助，http://chenzhenianqing.cn/articles/786.html

本人Redis-2.8.2的源碼註釋已經放到Github中，有須要的讀者能夠下載，我也會在後續的時間中更新，https://github.com/xkeyideal/annotated-redis-2.8.2

本人不怎麼會使用Git，望有人能教我一下。