最近一直在看redis的源码，准备把对源码的理解以及阅读心得记录下来，避免忘记并可以和大家分享、谈论。看代码的思路很简单，直接从main函数走起，先看看初始化过程。
redis中一个最重要的数据结构是redis_server，会创建一个这个结构的全局变量server，表示当前redis的配置及状态，初始化的大部分工作就是设置这个结构的属性。
可以把初始化工作主要划分为4个部分：
1）为server设置默认值
2）解析命令行参数
3）解析配置文件
4）初始化server
初始化完成后，就会启动事件循环，以接收、服务请求。下面分步骤解析main函数，不会关注sentinel逻辑。
（1）首先是main函数的起始部分，主要进行简单的初始化工作，包括设置collate，设置随机数种子，然后调用initServerConfig()为全局变量server设置默认值。
struct timeval tv;
/* We need to initialize our libraries, and the server configuration. */
#ifdef INIT_SETPROCTITLE_REPLACEMENT
spt_init(argc, argv);
#endif
// <MM>
// 使用环境变量初始化 字符串比较
// </MM>
setlocale(LC_COLLATE,"");
zmalloc_enable_thread_safeness();
zmalloc_set_oom_handler(redisOutOfMemoryHandler);
// <MM>
// 设置random的种子，之后会生成随机的run id，所有加入进程id因素
// </MM>
srand(time(NULL)^getpid());
gettimeofday(&tv,NULL);
dictSetHashFunctionSeed(tv.tv_sec^tv.tv_usec^getpid());
server.sentinel_mode = checkForSentinelMode(argc,argv);
// <MM>
// 为redisServer设置初始默认值
// </MM>
initServerConfig();
/* We need to init sentinel right now as parsing the configuration file
* in sentinel mode will have the effect of populating the sentinel
* data structures with master nodes to monitor. */
if (server.sentinel_mode) {
initSentinelConfig();
initSentinel();
}
在initServerConfig函数中，大部分是对server的属性设置默认值，还有一部分是调用populateCommandTable函数对redis的命令表初始化。全局变量redisCommandTable是redisCommand类型的数组，保存redis支持的所有命令。server.commands是一个dict，保存命令名到redisCommand的映射。populateCommandTable函数会遍历全局redisCommandTable表，把每条命令插入到server.commands中，根据每个命令的属性设置其flags。
redisCommand结构如下：
struct redisCommand {
// 命令名称，在server.commands命令表中，以命令名位key
char *name;
// 命令处理函数
redisCommandProc *proc;
// command的操作数，>0时表示确切的操作数，<0则表示至少有arity个操作数
int arity;
// 标记位的字符表示形式，主要用于命令表的初始化
char *sflags; /* Flags as string representation, one char per flag. */
// 属性标记位，bitwise，指定command的类型
int flags; /* The actual flags, obtained from the ‘sflags‘ field. */
// 下面的4个属性都是用于从客户端的一个请求解析出key，比如mset k1, v1, k2, v2 ...
/* Use a function to determine keys arguments in a command line. */
redisGetKeysProc *getkeys_proc;
/* What keys should be loaded in background when calling this command? */
int firstkey; /* The first argument that‘s a key (0 = no keys) */
int lastkey; /* The last argument that‘s a key */
int keystep; /* The step between first and last key */
// 统计信息
long long microseconds, calls;
};
redisCommand有属性proc，表示命令处理函数。在处理客户端请求时，获取到命令名，从server.commands字典中获取到redisCommand，然后回调其proc函数。
（2）命令行解析部分，主要是解析出命令行配置选项，以及通过命令行传入的配置项。然后会解析配置文件，主要是通过两个函数：
loadServerConfig：完成的功能很简单，就是将文件内容读到字符串中。并将通过命令行传入的配置项追加到该字符串后。
loadServerConfigFromString：从字符串中解析出配置项，并设置server的相关属性。
此步完成后，server中的简单属性（整数、字符串）基本都设置完成。
（3）接下来是初始化部分。设置为守护进程，创建pid文件，设置进程title以及打印启动日志。其中最重要的是initServer函数初始化基础数据结构。在初始化之后，需要从磁盘加载数据，可以是rdb或者aof。
// <MM>
// 守护进程
// </MM>
if (server.daemonize) daemonize();
initServer();
// <MM>
// 创建pid文件
// </MM>
if (server.daemonize) createPidFile();
// <MM>
// 设置进程名字
// </MM>
redisSetProcTitle(argv[0]);
// <MM>
// 打印启动日志
// </MM>
redisAsciiArt();
if (!server.sentinel_mode) {
/* Things not needed when running in Sentinel mode. */
redisLog(REDIS_WARNING,"Server started, Redis version " REDIS_VERSION);
#ifdef __linux__
linuxOvercommitMemoryWarning();
#endif
// <MM>
// 从磁盘加载数据，rdb或aof
// </MM>
loadDataFromDisk();
if (server.ipfd_count > 0)
redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port);
if (server.sofd > 0)
redisLog(REDIS_NOTICE,"The server is now ready to accept connections at %s", server.unixsocket);
} else {
sentinelIsRunning();
}
/* Warning the user about suspicious maxmemory setting. */
if (server.maxmemory > 0 && server.maxmemory < 1024*1024) {
redisLog(REDIS_WARNING,"WARNING: You specified a maxmemory value that is less than 1MB (current value is %llu bytes). Are you sure this is what you really want?", server.maxmemory);
}
initServerConfig中会对server的整型、字符串类型的属性设置，initServer主要对复合数据结构list、dict等初始化，并创建事件循环，初始化监听socket等。下面看下initServer函数：
首先，注册信号处理函数。
int j;
signal(SIGHUP, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
setupSignalHandlers();
如果设置开启syslog，则初始化。
if (server.syslog_enabled) {
openlog(server.syslog_ident, LOG_PID | LOG_NDELAY | LOG_NOWAIT,
server.syslog_facility);
}
初始化客户端相关的数据结构。redis会将所有连接的客户端，slave以及monitor的客户端组织成链表，此处主要是创建这些链表。
server.current_client = NULL;
server.clients = listCreate();
server.clients_to_close = listCreate();
server.slaves = listCreate();
server.monitors = listCreate();
server.slaveseldb = -1; /* Force to emit the first SELECT command. */
server.unblocked_clients = listCreate();
server.ready_keys = listCreate();
redis中会对经常使用的对象，创建常量池，以避免频繁创建、回收的开销。这些对象包括经常使用的响应内容以及小于10000的整数，还有表示bulk个数的响应头以及bulk长度的响应头，这两个响应头只包括长度小于32的。
// <MM>
// 创建常量池，避免频繁创建
// </MM>
createSharedObjects();
调整打开描述符限制，需要调用getrlimit和setrlimit。
// <MM>
// 根据maxclients配置，调整打开文件描述符限制
// </MM>
adjustOpenFilesLimit();
初始化事件循环，具体过程在事件循环一节中讲述。然后根据配置创建db数组。
// <MM>
// 初始化event loop，如是epoll实现，会调用epoll_create创建epoll的fd
// </MM>
server.el = aeCreateEventLoop(server.maxclients+REDIS_EVENTLOOP_FDSET_INCR);
server.db = zmalloc(sizeof(redisDb)*server.dbnum);
初始化监听socket，就是调用socket、bind、listen等，并将socket设置为非阻塞。如果配置了unix domain socket，也会进行相应的初始化。
/* Open the TCP listening socket for the user commands. */
if (server.port != 0 &&
listenToPort(server.port,server.ipfd,&server.ipfd_count) == REDIS_ERR)
exit(1);
/* Open the listening Unix domain socket. */
if (server.unixsocket != NULL) {
unlink(server.unixsocket); /* don‘t care if this fails */
server.sofd = anetUnixServer(server.neterr,server.unixsocket,
server.unixsocketperm, server.tcp_backlog);
if (server.sofd == ANET_ERR) {
redisLog(REDIS_WARNING, "Opening socket: %s", server.neterr);
exit(1);
}
anetNonBlock(NULL,server.sofd);
}
/* Abort if there are no listening sockets at all. */
if (server.ipfd_count == 0 && server.sofd < 0) {
redisLog(REDIS_WARNING, "Configured to not listen anywhere, exiting.");
exit(1);
}
接下来的代码，会初始化server.db数组中的每个db，主要创建相关的dict。然后关于pubsub、rdb、aof、replication相关数据结构的初始化。代码就不贴了。
然后添加定时器事件serverCron，在启动事件循环1ms后执行。redis中的事件循环就只有这一个，每0.1s（大约）执行一次，主要处理一些异步任务，比如清除expired keys，更新统计，check进行rdb、aof子进程的状态，然后会调用clientCron和databaseCron等。
// <MM>
// 注册serverCrom时间事件，启动event loop 1ms后执行
// </MM>
/* Create the serverCron() time event, that‘s our main way to process
* background operations. */
if(aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL) == AE_ERR) {
redisPanic("Can‘t create the serverCron time event.");
exit(1);
}
将所有监听socket添加到事件循环。可以看到会有acceptTcpHandler处理客户端连接的建立。
// <MM>
// 为所有的监听socket添加file event，事件处理器是acceptTcpHandler用于处理连接的创建
// </MM>
/* Create an event handler for accepting new connections in TCP and Unix
* domain sockets. */
for (j = 0; j < server.ipfd_count; j++) {
if (aeCreateFileEvent(server.el, server.ipfd[j], AE_READABLE,
acceptTcpHandler,NULL) == AE_ERR)
{
redisPanic(
"Unrecoverable error creating server.ipfd file event.");
}
}
if (server.sofd > 0 && aeCreateFileEvent(server.el,server.sofd,AE_READABLE,
acceptUnixHandler,NULL) == AE_ERR) redisPanic("Unrecoverable error creating server.sofd file event.");
如果开启aof，则创建aof文件。
/* Open the AOF file if needed. */
if (server.aof_state == REDIS_AOF_ON) {
server.aof_fd = open(server.aof_filename,
O_WRONLY|O_APPEND|O_CREAT,0644);
if (server.aof_fd == -1) {
redisLog(REDIS_WARNING, "Can‘t open the append-only file: %s",
strerror(errno));
exit(1);
}
}
最后部分，校验并设置maxmemory配置，初始化lua脚本、slow log以及latency monitor，最后的bioInit初始化异步io线程。redis是单线程，对于重IO操作，比如aof的fsync的调用会由异步线程调用，避免阻塞主线程的事件循环。以上就是initServer函数。
/* 32 bit instances are limited to 4GB of address space, so if there is
* no explicit limit in the user provided configuration we set a limit
* at 3 GB using maxmemory with ‘noeviction‘ policy‘. This avoids
* useless crashes of the Redis instance for out of memory. */
if (server.arch_bits == 32 && server.maxmemory == 0) {
redisLog(REDIS_WARNING,"Warning: 32 bit instance detected but no memory limit set. Setting 3 GB maxmemory limit with ‘noeviction‘ policy now.");
server.maxmemory = 3072LL*(1024*1024); /* 3 GB */
server.maxmemory_policy = REDIS_MAXMEMORY_NO_EVICTION;
}
replicationScriptCacheInit();
scriptingInit();
slowlogInit();
latencyMonitorInit();
// <MM>
// 初始化异步阻塞IO处理线程
// </MM>
bioInit();
（4）main函数的最后，是启动事件循环。在事件循环的每次迭代，sleep之前会调用beforeSleep函数，进行一些异步处理。此处首先设置beforeSleep函数，然后启动aeMain事件循环。当从事件循环退出后，清理事件循环，然后退出。
aeSetBeforeSleepProc(server.el,beforeSleep);
// <MM>
// 开启event loop
// </MM>
aeMain(server.el);
aeDeleteEventLoop(server.el);
return 0;
以上便是redis的初始化、启动过程。总体上，比较简单，相比nginx的配置文件解析，模块初始化，进程初始化要简单不少，读起来不会太费劲。下一篇介绍事件循环。