redis服务器实例的执行入口函数main(redis.c):
2064 /* =================================== Main! ================================ */
2065
2066 int main(int argc, char **argv) {
2067 initServerConfig();
2068 initServer();
2069 if (argc == 2) {
2070 ResetServerSaveParams();
2071 loadServerConfig(argv[1]);
2072 redisLog(REDIS_NOTICE,"Configuration loaded");
2073 } else if (argc > 2) {
2074 fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n");
2075 exit(1);
2076 }
2077 redisLog(REDIS_NOTICE,"Server started");
2078 if (loadDb("dump.rdb") == REDIS_OK)
2079 redisLog(REDIS_NOTICE,"DB loaded from disk");
2080 if (aeCreateFileEvent(server.el, server.fd, AE_READABLE,
2081 acceptHandler, NULL, NULL) == AE_ERR) oom("creating file event");
2082 redisLog(REDIS_NOTICE,"The server is now ready to accept connections");
2083 aeMain(server.el);
2084 aeDeleteEventLoop(server.el);
2085 return 0;
2086 }首先进行初始化操作,通过调用initServerConfig和initServer 设置全局对象server的初始值,其类型为:
93 /* Global server state structure */
94 struct redisServer {
95 int port;
96 int fd;
97 dict **dict;
98 long long dirty; /* changes to DB from the last save */
99 list *clients;
100 char neterr[ANET_ERR_LEN];
101 aeEventLoop *el;
102 int verbosity;
103 int cronloops;
104 int maxidletime;
105 int dbnum;
106 list *objfreelist; /* A list of freed objects to avoid malloc() */
107 int bgsaveinprogress;
108 time_t lastsave;
109 struct saveparam *saveparams;
110 int saveparamslen;
111 char *logfile;
112 };下面是这个两个函数分别对该全局对象的初始化.
函数initServerConfig的实现(redis.c):
556 static void initServerConfig() {
557 server.dbnum = REDIS_DEFAULT_DBNUM;
558 server.port = REDIS_SERVERPORT;
559 server.verbosity = REDIS_DEBUG;
560 server.maxidletime = REDIS_MAXIDLETIME;
561 server.saveparams = NULL;
562 server.logfile = NULL; /* NULL = log on standard output */
563 ResetServerSaveParams();
564
565 appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */
566 appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */
567 appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
568 }全局变量server默认有16个数据库对象, 这个参数可以通过启动时加载的配置文件进行覆盖.redis底层通过TCP网络协议进行数据传输, 因此需要监听服务器端口,默认是端口6379.当已经连接到redis服务器的客户端处于空闲状态时, redis服务器有可能会关闭这个客户端的连接.这里的空闲指的是redis协议层面上的空闲,而不是TCP层次的连接空闲.字段verbosity和logfile控制log输出, 可以输出到指定的文件,也可以输出到控制台.字段saveparams 在定时事件处理中使用, 定时事件有可能会把内存中的数据保存到磁盘, 判断的依据就是该字段的值,这里设置了三个标准, 满足其中任何一个,定时事件都会把内存数据保存到磁盘文件.
函数initServer的实现(redis.c):
570 static void initServer() {
571 int j;
572
573 signal(SIGHUP, SIG_IGN);
574 signal(SIGPIPE, SIG_IGN);
575
576 server.clients = listCreate();
577 server.objfreelist = listCreate();
578 createSharedObjects();
579 server.el = aeCreateEventLoop();
580 server.dict = malloc(sizeof(dict*)*server.dbnum);
581 if (!server.dict || !server.clients || !server.el || !server.objfreelist)
582 oom("server initialization"); /* Fatal OOM */
583 server.fd = anetTcpServer(server.neterr, server.port, NULL);
584 if (server.fd == -1) {
585 redisLog(REDIS_WARNING, "Opening TCP port: %s", server.neterr);
586 exit(1);
587 }
588 for (j = 0; j < server.dbnum; j++) {
589 server.dict[j] = dictCreate(&sdsDictType,NULL);
590 if (!server.dict[j])
591 oom("server initialization"); /* Fatal OOM */
592 }
593 server.cronloops = 0;
594 server.bgsaveinprogress = 0;
595 server.lastsave = time(NULL);
596 server.dirty = 0;
597 aeCreateTimeEvent(server.el, 1000, serverCron, NULL, NULL);
598 }字段clients是个list类型,用于记录连接到redis服务器的客户端.字段objfreelist也是个list类型,用于保存空闲的robj类型的对象,objfreelist相当于一个robj类型的对象池, 在分配robj类型的对象时,如果该对象池中有空闲对象,则直接取走用, 否则需要动态分配robj类型的对象.
函数listCreate创建一个list类型的对象,其实现为(adlist.c):
8 /* Create a new list. The created list can be freed with
9 * AlFreeList(), but private value of every node need to be freed
10 * by the user before to call AlFreeList().
11 *
12 * On error, NULL is returned. Otherwise the pointer to the new list. */
13 list *listCreate(void)
14 {
15 struct list *list;
16
17 if ((list = malloc(sizeof(*list))) == NULL)
18 return NULL;
19 list->head = list->tail = NULL;
20 list->len = 0;
21 list->dup = NULL;
22 list->free = NULL;
23 list->match = NULL;
24 return list;
25 }和list相关的结构定义为(adlist.h):
10 typedef struct listNode {
11 struct listNode *prev;
12 struct listNode *next;
13 void *value;
14 } listNode;
15
16 typedef struct list {
17 listNode *head;
18 listNode *tail;
19 void *(*dup)(void *ptr);
20 void (*free)(void *ptr);
21 int (*match)(void *ptr, void *key);
22 int len;
23 } list;list链表结构图如下所示:
函数createSharedObjects创建了一些共享的robj类型的对象, 这些对象都是根据不同的客户端命令,响应客户端时发送的.函数aeCreateEventLoop创建了一个事件循环对象,并赋值给server.el, redis服务器的整个逻辑就不断的在事件循环中处理到来的事件.事件循环相关结构的定义为(ae.h):
11 /* File event structure */
12 typedef struct aeFileEvent {
13 int fd;
14 int mask; /* one of AE_(READABLE|WRITABLE|EXCEPTION) */
15 aeFileProc *fileProc;
16 aeEventFinalizerProc *finalizerProc;
17 void *clientData;
18 struct aeFileEvent *next;
19 } aeFileEvent;
20
21 /* Time event structure */
22 typedef struct aeTimeEvent {
23 long long id; /* time event identifier. */
24 long when_sec; /* seconds */
25 long when_ms; /* milliseconds */
26 aeTimeProc *timeProc;
27 aeEventFinalizerProc *finalizerProc;
28 void *clientData;
29 struct aeTimeEvent *next;
30 } aeTimeEvent;
31
32 /* State of an event based program */
33 typedef struct aeEventLoop {
34 long long timeEventNextId;
35 aeFileEvent *fileEventHead;
36 aeTimeEvent *timeEventHead;
37 int stop;
38 } aeEventLoop;类型aeEventLoop管理两类事件对象, 包括文件事件对象和定时事件对象, 字段fileEventHead和timeEventHead分别指向这两类事件对象的链表头.
接着初始化指针数组server.dict,每个指针指向函数dictCreate动态分配的dict对象.函数anetTcpServer通过socket接口创建描述符,并绑定到之前的默认端口上, redis服务器就是通过这个socket接口来接收客户端的连接请求.字段cronloops记录定时事件的触发次数.字段bgsaveinprogress标识是否正在异步保存内存数据到磁盘文件.字段dirty记录客户端更新操作的次数.字段lastsave记录上次写磁盘的时间戳.redis服务器使用dirty和lastsave这两个字段来判断是否保存内存数据到磁盘.在函数initServer的最后,使用函数aeCreateTimeEvent创建一个定时事件对象.
函数aeDeleteTimeEvent的实现(ae.c):
100 long long aeCreateTimeEvent(aeEventLoop *eventLoop, long long milliseconds,
101 aeTimeProc *proc, void *clientData,
102 aeEventFinalizerProc *finalizerProc)
103 {
104 long long id = eventLoop->timeEventNextId++;
105 aeTimeEvent *te;
106
107 te = malloc(sizeof(*te));
108 if (te == NULL) return AE_ERR;
109 te->id = id;
110 aeAddMillisecondsToNow(milliseconds,&te->when_sec,&te->when_ms);
111 te->timeProc = proc;
112 te->finalizerProc = finalizerProc;
113 te->clientData = clientData;
114 te->next = eventLoop->timeEventHead;
115 eventLoop->timeEventHead = te;
116 return id;
117 }定时事件在当前时间+milliseconds毫秒后触发, 该参数传入的是1000,因此在1秒后触发.定时事件触发后将执行函数指针timeProc中的逻辑,该参数被传入的地址是serverCron.函数指针finalizerProc在定时事件被删除的时候调用,来处理客户端私有数据对象clientData.新创建的定时事件被放到事件循环对象eventLoop的链表timeEventHead中.
回到main函数, 如果启动redis时,指定了配置文件参数, 则读取配置文件中的数据,并覆盖全局对象server中相同字段的值.接着尝试装载之前保存到磁盘的数据库文件dump.rdb,函数loadDb的实现完全是根据写入磁盘数据库文件的saveDb函数来实现的, 后续我们在定时事件中再看saveDb实现,在此略过分析loadDb的实现.接下来调用函数aeCreateFileEvent创建一个文件事件对象, 用来监听客户端的连接请求,该对象只在可读时候被触发, 触发后的执行函数为acceptHandler,该函数获得连接客户端的socket描述符.
函数aeCreateFileEvent的实现(ae.c):
38 int aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask,
39 aeFileProc *proc, void *clientData,
40 aeEventFinalizerProc *finalizerProc)
41 {
42 aeFileEvent *fe;
43
44 fe = malloc(sizeof(*fe));
45 if (fe == NULL) return AE_ERR;
46 fe->fd = fd;
47 fe->mask = mask;
48 fe->fileProc = proc;
49 fe->finalizerProc = finalizerProc;
50 fe->clientData = clientData;
51 fe->next = eventLoop->fileEventHead;
52 eventLoop->fileEventHead = fe;
53 return AE_OK;
54 }
文件事件对象中有mask字段, 因为监听的文件描述符被触发时, 可能是可读,可写,或者带外消息, 其他字段含义类似定时事件结构.通过初始化过程, redis服务器实例中会存在一个定时事件对象和一个文件事件对象, 这两个对象一直存在. 当然随着系统运行, 当新的客户端连接到redis服务器时, 会动态的创建新的文件事件对象.
函数main中通过调用函数aeMain进入事件循环处理主流程.
函数aeMain的实现(ae.c):
313 void aeMain(aeEventLoop *eventLoop)
314 {
315 eventLoop->stop = 0;
316 while (!eventLoop->stop)
317 aeProcessEvents(eventLoop, AE_ALL_EVENTS);
318 }通过调用aeProcessEvents监听并处理客户端的连接请求和redis协议命令.