文章導航
Redis源碼系列的初衷，是幫助我們更好地理解Redis，更懂Redis，而怎么才能懂，光看是不夠的，建議跟着下面的這一篇，把環境搭建起來，后續可以自己閱讀源碼，或者跟着我這邊一起閱讀。由於我用c也是好幾年以前了，些許錯誤在所難免，希望讀者能不吝指出。
曹工說Redis源碼（1）-- redis debug環境搭建，使用clion，達到和調試java一樣的效果
一些補充知識
項目結構及入口
除了大學那些玩具，一個真正的項目，都是由大量源代碼文件組成一個工程。在Java里，一個 java 文件要使用其他 java 文件中的函數、類型、變量等，都需要使用import語句來引入。在c語言里，也是一樣的，在c語言中，要引入其他文件的功能，需要使用include語句。
比如，在redis的主入口，redis.c文件中，就包含了如下一堆語句：
#include "redis.h"
#include "cluster.h"
#include "slowlog.h"
#include "bio.h"
#include <time.h>
#include <signal.h>
其中，以<開頭的，比如<time.h>是標准庫的頭文件，會在系統指定的路徑下查找，可類比為jdk官方的class；"bio.h"這種，以""包裹的，則是工程里自定義的。
比如，time.h，我在linux的以下路徑查找到了：
[root@mini1 src]# locate time.h
/usr/include/time.h
其他include相關知識，可以參考：
https://www.runoob.com/cprogramming/c-header-files.html
我對頭文件的理解
一般來說，我們會在.c文件中，去編寫我們的業務邏輯方法，其中，一些方法，可能是只在本文件內部用到的，類似於java class的private方法；一些方法呢，可能是需要在外部的其他源碼文件中，也需要用到的，這些方法，要怎么才能讓外部可以使用呢？
就是通過頭文件機制，可以理解為各大高級語言中的接口，在java中，定義一個class，雖然可以直接把方法設為public，其他類可以直接訪問；但是，在平時的業務開發中，我們一般並不會直接訪問一個實現類，而是通過它實現的接口去訪問；一個好的實現類，也不應該把沒在接口中定義的方法，設為public權限。
說回頭文件，比如有個源碼文件test.c 如下：
long long ustime(void) {
struct timeval tv;
long long ust;
gettimeofday(&tv, NULL);
ust = ((long long)tv.tv_sec)*1000000;
ust += tv.tv_usec;
return ust;
}
/* Return the UNIX time in milliseconds */
// 返回毫秒格式的 UNIX 時間
// 1 秒 = 1 000 毫秒
long long mstime(void) {
return ustime()/1000;
}
這個文件里，定義了2個方法，但假設我們只需要對外暴露mstime(void)方法，那么，頭文件test.h應該是下面這樣的：
long long mstime(void);
這樣的話，我們的另一個方法，ustime，對外就不可見了。
總之，大家可以把頭文件理解為實現類要對外暴露的接口；大家可能覺得我的比喻不恰當，為啥把c文件，說成實現類，實際上，我們之前在華為的時候，確實是用c++的思想，面向對象的思想，來寫c語言的。
我看到網上一篇文章，這里引用一下（https://zhuanlan.zhihu.com/p/57882822）：
反觀Redis，他是純C編碼，但是融入了面向對象的思想。和上述觀點截然相反，可謂是『用C++去設計，用C編碼』。當然本文目的並非挑起語言之爭，各種語言自有其利弊，開源項目的語言選擇也主要是由於項目作者的個人經歷和主觀意願。
但是c語言中的頭文件，和java這些語言中的接口，還是不同的；在java中，接口和實現類一樣，最終都是編譯為獨立的class文件。
在c語言中，在編譯實現類之前，會有一個預處理的過程，預處理的過程，就是把include語句，直接替換為被include的頭文件的內容，比如，以菜鳥教程中的例子舉例：
header.h
char *test (void);
在如下的 program.c中，需要使用上面的header.h中的test方法，則需要include：
int x;
#include "header.h"
int main (void)
{
puts (test ());
}
經過預處理后，（就是進行簡單的replace），效果如下：
int x;
char *test (void);
int main (void)
{
puts (test ());
}
我們可以使用如下命令，來演示這個過程：
[root@mini1 test]# gcc -E program.c
int x;
# 1 "header.h" 1
char *test (void);
# 3 "program.c" 2
int main (void)
{
puts (test ());
}
從上面可以看到，已經replace進去了；如果我們include兩次，會怎樣？
[root@mini1 test]# gcc -E program.c
int x;
# 1 "header.h" 1
char *test (void);
# 3 "program.c" 2
# 1 "header.h" 1
char *test (void);
# 4 "program.c" 2
int main (void)
{
puts (test ());
}
可以發現，這個header的內容，出現了2次，重復了。但是上面這種情況，並不會報錯，無非是方法被定義了兩次。
為什么頭文件里都要來一句ifndef
大家看頭文件，都會發現如下語句，比如在redis.h中：
#ifndef __REDIS_H
#define __REDIS_H
#include "fmacros.h"
#include "config.h"
...
typedef struct redisObject {
// 類型
unsigned type:4;
// 編碼
unsigned encoding:4;
// 對象最后一次被訪問的時間
unsigned lru:REDIS_LRU_BITS; /* lru time (relative to server.lruclock) */
// 引用計數
int refcount;
// 指向實際值的指針
void *ptr;
} robj;
...
#endif
可以看到，最開始，有一句：
#ifndef __REDIS_H
#define __REDIS_H
結尾有一句：
#endif
這個就是為了解決如下問題：
在頭文件被重復引入時（間接地，或直接地，被include了兩次），如果不加這個，就會導致頭文件里的內容，被引入兩次；加了這個之后呢，即使被include了兩次，程序在運行時，一開始，發現沒有定義__REDIS_H這個宏，然后定義它；等到程序遇到第二次include的內容時，發現__REDIS_H這個宏已經被定義了，就直接跳過了，這樣保證了同一個頭文件，即使被多次include，也能保證其內容，只被解析一次。
另外，像方法聲明這種，定義多次可能沒事，但是，如果在頭文件里，有如下類型定義呢：
typedef char my_char;
char *test (void);
如果重復include同一個頭文件的話，就會造成類型重復定義。不過，很奇怪的是，我在centos 7.3.1611上試了，gcc版本：gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-16)，竟然沒報錯。看來我之前的c語言知識，也沒學到家。
我在網上暫時也沒找到重復include，具體的害處是啥，網上找到的答案就兩種：
- 在header文件里定義了全局變量；
- 浪費編譯時間
但是，第一個答案，嚴格來說 ，是不存在的，因為公司一般禁止在頭文件中定義變量。
有個知乎問題，大家可以看看：頭文件被重復包含究竟有哪些危害？
華為c語言編程規范中，對頭文件的部分規定
大家可以自行搜索：華為技術有限公司c語言編程規范
我這里僅截取部分：
規則1.6 禁止在頭文件中定義變量。
說明： 在頭文件中定義變量，將會由於頭文件被其他.c文件包含而導致變量重復定義。
規則1.7 只能通過包含頭文件的方式使用其他.c提供的接口，禁止在.c中通過extern的方式使用外部
函數接口、變量。
說明：若a.c使用了b.c定義的foo()函數，則應當在b.h中聲明extern int foo(int input)；並在a.c
中通過#include <b.h>來使用foo。禁止通過在a.c中直接寫extern int foo(int input);來使用foo，
后面這種寫法容易在foo改變時可能導致聲明和定義不一致。
這里的1.7，也是和我們的理解是一致的，頭文件就是一個實現模塊的對外接口，在里面一般只能允許放以下內容：
- 類型定義
- 宏定義
- 函數的聲明（不包括實現）
- 變量的聲明（不是定義）
最后這一點，我要補充下。我們剛才禁止了，在頭文件中定義變量，所以，我們的變量，是在c文件中定義。比如，在redis.c中，定義了一個全局變量：
/* Global vars */
struct redisServer server; /* server global state */
這么一個重要的全局變量，基本維護了redis-server的一個實例的全部狀態值，只在自己redis.c中使用，是不可能的。那要怎么在其他文件使用呢，就要在redis.h頭文件中進行如下聲明：
/*-----------------------------------------------------------------------------
* Extern declarations
*----------------------------------------------------------------------------*/
extern struct redisServer server;
關於類型定義
一般使用struct來定義一個結構體，類似高級語言中的class。
比如，redis中的字符串，一般會使用sds這個數據結構來存儲，其結構體定義就像下面這樣：
struct sdshdr {
// buf 中已占用空間的長度
int len;
// buf 中剩余可用空間的長度
int free;
// 數據空間
char buf[];
};
另外，c語言中，會大量使用typedef來定義一個類型的別名。
具體可以參考這個教程看看：
https://www.runoob.com/cprogramming/c-typedef.html
關於指針
基礎知識：https://www.runoob.com/cprogramming/c-pointers.html
我這里說下我對指針的理解，指針一般指向一個內存地址，大家可以先不管這個指針是什么類型，事實上，當我們不關心其指向的地址上，是什么數據類型時，可以直接定義為 void * ptr。
這個指針，假設指向A這個地址，當我們認為上面存儲的是一個char時，就可以把這個指針，從void *強轉為char * 類型，然后對該指針解引用的話，因為char類型只占用一個字節，所以只需要，從該指針指向的位置開始，取當前這個字節的內容，然后解析為char，就能獲取到這個地址上的char值。
如果我們把void * 強轉為int *的話，對其解引用時，就會取當前指針位置開始的4個字節，因為整數占4個字節，然后將其轉為整數。
總的來說，對一個指針解引用時，首先就是看當前指針的數據類型，比如 int *指針，那么說明指向int，就會取4個字節來進行解引用；如果是指向一個結構體，就會計算結構體占用的字節數，然后取對應的字節，來解引用為結構體類型的變量。
這部分，大家可以看看這塊：
https://www.runoob.com/cprogramming/c-data-types.html
https://www.runoob.com/cprogramming/c-pointer-arithmetic.html
redis啟動過程之配置項初始化
前面說了很多，我們本講也不夠講完全部的redis啟動過程了，可能還要兩講的樣子，本講先講解一部分。
啟動入口在：redis.c中的main 方法，如果使用我這邊的代碼來搭建調試環境，可以直接啟動redis-server。
int main(int argc, char **argv) {
struct timeval tv;
/**
* 1 設置時區
*/
setlocale(LC_COLLATE,"");
/**
*2
*/
zmalloc_enable_thread_safeness();
// 3
zmalloc_set_oom_handler(redisOutOfMemoryHandler);
// 4
srand(time(NULL)^getpid());
// 5
gettimeofday(&tv,NULL);
// 6
dictSetHashFunctionSeed(tv.tv_sec^tv.tv_usec^getpid());
// 檢查服務器是否以 Sentinel 模式啟動
server.sentinel_mode = checkForSentinelMode(argc,argv);
// 7 初始化服務器
initServerConfig();
-
1處，設置時區
-
2處，設置進行內存分配的線程的數量，這里會設為1
-
3處，設置oom發生時的函數指針，函數指針指向一個函數，類似於java 8中，lambda表達式中，丟一個方法的引用給流；函數指針會在oom時，被回調，總體來說，就類似於java中的模板設計模式或者策略模式。
-
4處，設置隨機數的種子
-
5處，獲取當前時間，設置到
tv這個變量中注意，這里把tv的地址傳進去了，這是c語言中典型的用法，類似於java中傳一個對象的引用進去，然后在方法內部，會修改該對象的內部field等
-
6處，設置hash函數的種子
-
7處，初始化服務器。
這里重點說下7處：
void initServerConfig() {
int j;
// 服務器狀態
// 設置服務器的運行 ID
getRandomHexChars(server.runid,REDIS_RUN_ID_SIZE);
// 設置默認配置文件路徑
server.configfile = NULL;
// 設置默認服務器頻率
server.hz = REDIS_DEFAULT_HZ;
// 為運行 ID 加上結尾字符
server.runid[REDIS_RUN_ID_SIZE] = '\0';
// 設置服務器的運行架構
server.arch_bits = (sizeof(long) == 8) ? 64 : 32;
// 設置默認服務器端口號
server.port = REDIS_SERVERPORT;
// tcp 全連接隊列的長度
server.tcp_backlog = REDIS_TCP_BACKLOG;
// 綁定的地址的數量
server.bindaddr_count = 0;
// UNIX socket path
server.unixsocket = NULL;
server.unixsocketperm = REDIS_DEFAULT_UNIX_SOCKET_PERM;
// 綁定的 TCP socket file descriptors
server.ipfd_count = 0;
server.sofd = -1;
// redis可使用的redis db的數量
server.dbnum = REDIS_DEFAULT_DBNUM;
// redis 日志級別
server.verbosity = REDIS_DEFAULT_VERBOSITY;
// Client timeout in seconds,客戶端最大空閑時間;超過這個時間的客戶端，會被強制關閉
server.maxidletime = REDIS_MAXIDLETIME;
// Set SO_KEEPALIVE if non-zero. 如果設為非0，則開啟tcp的SO_KEEPALIVE
server.tcpkeepalive = REDIS_DEFAULT_TCP_KEEPALIVE;
// 打開這個選項，會周期性地清理過期key
server.active_expire_enabled = 1;
// 客戶端發來的請求中，查詢緩存的最大值；比如一個set命令，value的大小就會和這個緩沖區大小比較，
// 如果大了，就根本放不進緩沖區
server.client_max_querybuf_len = REDIS_MAX_QUERYBUF_LEN;
// rdb保存參數，比如每60s保存，n個鍵被修改了保存，之類的
server.saveparams = NULL;
// 如果為1，表示服務器正在從磁盤載入數據： We are loading data from disk if true
server.loading = 0;
// 日志文件位置
server.logfile = zstrdup(REDIS_DEFAULT_LOGFILE);
// 開啟syslog等機制
server.syslog_enabled = REDIS_DEFAULT_SYSLOG_ENABLED;
server.syslog_ident = zstrdup(REDIS_DEFAULT_SYSLOG_IDENT);
server.syslog_facility = LOG_LOCAL0;
// 后台運行
server.daemonize = REDIS_DEFAULT_DAEMONIZE;
// aof狀態
server.aof_state = REDIS_AOF_OFF;
// aof的刷磁盤策略，默認每秒刷盤
server.aof_fsync = REDIS_DEFAULT_AOF_FSYNC;
// 正在rewrite時，不刷盤
server.aof_no_fsync_on_rewrite = REDIS_DEFAULT_AOF_NO_FSYNC_ON_REWRITE;
// Rewrite AOF if % growth is > M and...
server.aof_rewrite_perc = REDIS_AOF_REWRITE_PERC;
// the AOF file is at least N bytes. aof達到多大時，觸發rewrite
server.aof_rewrite_min_size = REDIS_AOF_REWRITE_MIN_SIZE;
// 最后一次執行 BGREWRITEAOF 時， AOF 文件的大小
server.aof_rewrite_base_size = 0;
// Rewrite once BGSAVE terminates.開啟該選項時，BGSAVE結束時，觸發rewrite
server.aof_rewrite_scheduled = 0;
// 最近一次aof進行fsync的時間
server.aof_last_fsync = time(NULL);
// 最近一次aof重寫，消耗的時間
server.aof_rewrite_time_last = -1;
// Current AOF rewrite start time.
server.aof_rewrite_time_start = -1;
// 最后一次執行 BGREWRITEAOF 的結果
server.aof_lastbgrewrite_status = REDIS_OK;
// 記錄 AOF 的 fsync 操作被推遲了多少次
server.aof_delayed_fsync = 0;
// File descriptor of currently selected AOF file
server.aof_fd = -1;
// AOF 的當前目標數據庫
server.aof_selected_db = -1; /* Make sure the first time will not match */
// UNIX time of postponed AOF flush
server.aof_flush_postponed_start = 0;
// fsync incrementally while rewriting? 重寫過程中，增量觸發fsync
server.aof_rewrite_incremental_fsync = REDIS_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC;
// pid文件
server.pidfile = zstrdup(REDIS_DEFAULT_PID_FILE);
// rdb 文件名
server.rdb_filename = zstrdup(REDIS_DEFAULT_RDB_FILENAME);
// aof 文件名
server.aof_filename = zstrdup(REDIS_DEFAULT_AOF_FILENAME);
// 是否要密碼
server.requirepass = NULL;
// 是否進行rdb壓縮
server.rdb_compression = REDIS_DEFAULT_RDB_COMPRESSION;
// rdb checksum
server.rdb_checksum = REDIS_DEFAULT_RDB_CHECKSUM;
// bgsave失敗，停止寫入
server.stop_writes_on_bgsave_err = REDIS_DEFAULT_STOP_WRITES_ON_BGSAVE_ERROR;
// 在執行 serverCron() 時進行漸進式 rehash
server.activerehashing = REDIS_DEFAULT_ACTIVE_REHASHING;
server.notify_keyspace_events = 0;
// 支持的最大客戶端數量
server.maxclients = REDIS_MAX_CLIENTS;
// bpop阻塞的客戶端
server.bpop_blocked_clients = 0;
// 可以使用的最大內存
server.maxmemory = REDIS_DEFAULT_MAXMEMORY;
// 內存淘汰策略，也就是key的過期策略
server.maxmemory_policy = REDIS_DEFAULT_MAXMEMORY_POLICY;
server.maxmemory_samples = REDIS_DEFAULT_MAXMEMORY_SAMPLES;
// hash表的元素小於這個值時，使用ziplist 編碼模式;以下幾個類似
server.hash_max_ziplist_entries = REDIS_HASH_MAX_ZIPLIST_ENTRIES;
server.hash_max_ziplist_value = REDIS_HASH_MAX_ZIPLIST_VALUE;
server.list_max_ziplist_entries = REDIS_LIST_MAX_ZIPLIST_ENTRIES;
server.list_max_ziplist_value = REDIS_LIST_MAX_ZIPLIST_VALUE;
server.set_max_intset_entries = REDIS_SET_MAX_INTSET_ENTRIES;
server.zset_max_ziplist_entries = REDIS_ZSET_MAX_ZIPLIST_ENTRIES;
server.zset_max_ziplist_value = REDIS_ZSET_MAX_ZIPLIST_VALUE;
server.hll_sparse_max_bytes = REDIS_DEFAULT_HLL_SPARSE_MAX_BYTES;
// 該標識打開時，表示正在關閉服務器
server.shutdown_asap = 0;
// 復制相關
server.repl_ping_slave_period = REDIS_REPL_PING_SLAVE_PERIOD;
server.repl_timeout = REDIS_REPL_TIMEOUT;
server.repl_min_slaves_to_write = REDIS_DEFAULT_MIN_SLAVES_TO_WRITE;
server.repl_min_slaves_max_lag = REDIS_DEFAULT_MIN_SLAVES_MAX_LAG;
// cluster模式相關
server.cluster_enabled = 0;
server.cluster_node_timeout = REDIS_CLUSTER_DEFAULT_NODE_TIMEOUT;
server.cluster_migration_barrier = REDIS_CLUSTER_DEFAULT_MIGRATION_BARRIER;
server.cluster_configfile = zstrdup(REDIS_DEFAULT_CLUSTER_CONFIG_FILE);
// lua腳本
server.lua_caller = NULL;
server.lua_time_limit = REDIS_LUA_TIME_LIMIT;
server.lua_client = NULL;
server.lua_timedout = 0;
//
server.migrate_cached_sockets = dictCreate(&migrateCacheDictType,NULL);
server.loading_process_events_interval_bytes = (1024*1024*2);
// 初始化 LRU 時間
server.lruclock = getLRUClock();
// 初始化並設置保存條件
resetServerSaveParams();
// rdb的默認保存策略
appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */
appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */
appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
/* Replication related */
// 初始化和復制相關的狀態
server.masterauth = NULL;
server.masterhost = NULL;
server.masterport = 6379;
server.master = NULL;
server.cached_master = NULL;
server.repl_master_initial_offset = -1;
server.repl_state = REDIS_REPL_NONE;
server.repl_syncio_timeout = REDIS_REPL_SYNCIO_TIMEOUT;
server.repl_serve_stale_data = REDIS_DEFAULT_SLAVE_SERVE_STALE_DATA;
server.repl_slave_ro = REDIS_DEFAULT_SLAVE_READ_ONLY;
server.repl_down_since = 0; /* Never connected, repl is down since EVER. */
server.repl_disable_tcp_nodelay = REDIS_DEFAULT_REPL_DISABLE_TCP_NODELAY;
server.slave_priority = REDIS_DEFAULT_SLAVE_PRIORITY;
server.master_repl_offset = 0;
/* Replication partial resync backlog */
// 初始化 PSYNC 命令所使用的 backlog
server.repl_backlog = NULL;
server.repl_backlog_size = REDIS_DEFAULT_REPL_BACKLOG_SIZE;
server.repl_backlog_histlen = 0;
server.repl_backlog_idx = 0;
server.repl_backlog_off = 0;
server.repl_backlog_time_limit = REDIS_DEFAULT_REPL_BACKLOG_TIME_LIMIT;
server.repl_no_slaves_since = time(NULL);
/* Client output buffer limits */
// 設置客戶端的輸出緩沖區限制
for (j = 0; j < REDIS_CLIENT_LIMIT_NUM_CLASSES; j++)
server.client_obuf_limits[j] = clientBufferLimitsDefaults[j];
/* Double constants initialization */
// 初始化浮點常量
R_Zero = 0.0;
R_PosInf = 1.0/R_Zero;
R_NegInf = -1.0/R_Zero;
R_Nan = R_Zero/R_Zero;
// 初始化命令表,比如get、set、hset等各自的處理函數，放進一個hash表，方便后續處理請求
server.commands = dictCreate(&commandTableDictType,NULL);
server.orig_commands = dictCreate(&commandTableDictType,NULL);
populateCommandTable();
server.delCommand = lookupCommandByCString("del");
server.multiCommand = lookupCommandByCString("multi");
server.lpushCommand = lookupCommandByCString("lpush");
server.lpopCommand = lookupCommandByCString("lpop");
server.rpopCommand = lookupCommandByCString("rpop");
/* Slow log */
// 初始化慢查詢日志
server.slowlog_log_slower_than = REDIS_SLOWLOG_LOG_SLOWER_THAN;
server.slowlog_max_len = REDIS_SLOWLOG_MAX_LEN;
/* Debugging */
// 初始化調試項
server.assert_failed = "<no assertion failed>";
server.assert_file = "<no file>";
server.assert_line = 0;
server.bug_report_start = 0;
server.watchdog_period = 0;
}
以上都加了注釋，我們可以先不看：復制、cluster、lua等相關的，先看其他的。
總結
太久沒碰c了，有些遺忘，不過總體來說，並不難，難的是內存泄露之類，但我們只是debug學習使用，不用擔心這些問題。
指針那一塊，需要一點點基礎，大家可以花點時間學一下。
大家看看有啥問題或者建議，歡迎指出。