一、aeCreateEventLoop & aeCreateFileEvent
上一篇文章中，我们已经将服务器启动，只是其中有些细节我们跳过了，比如aeCreateEventLoop函数到底做了什么？ 接下来我们要分析ae.c文件，它是整个Redis网络事件框架，其中定义了各个管理事件的函数，比如aeCreateFileEvent，aeDeleteFileEvent分别是注册新的事件和删除事件。
其实aeCreateEventLoop的作用主要是给server->loop申请空间。
//ae.c
aeEventLoop *aeCreateEventLoop(int setsize) {
aeEventLoop *eventLoop;
if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL) { //给eventLoop申请空间
goto err;
}
eventLoop->events = zmalloc(sizeof(aeFileEvent) * setsize); //给events链表申请空间
eventLoop->fired = zmalloc(sizeof(aeFiredEvent) * setsize); //给fired链表申请空间
if (eventLoop->events == NULL || eventLoop->fired == NULL) {
goto err;
}
eventLoop->setsize = setsize; //设置大小
eventLoop->lastTime = time(NULL); //设置lastTime=now
eventLoop->timeEventHead = NULL; //定时事件链表置空
eventLoop->timeEventNextId = 0; //定时事件的id为0
eventLoop->stop = 0; //stop为0
eventLoop->maxfd = -1; //最大文件描述符为0
eventLoop->beforesleep = NULL; //beforesleep设置为NULL
if (aeApiCreate(eventLoop) == -1) { //给EPOLL申请空间
goto err;
}
/* Events with mask == AE_NONE are not set. So let's initialize the vector with it. */
for (int i = 0; i < setsize; i++) {
eventLoop->events[i].mask = AE_NONE; //将每一个fd的事件初始化为0
}
return eventLoop;
err:
if (eventLoop) {
zfree(eventLoop->events);
zfree(eventLoop->fired);
zfree(eventLoop);
}
return NULL;
}
至此申请空间完成，我们整个EventLoop结构如下图所示：
我们完成了所有空间的申请和初始化工作：
loop->events : 是一个aeFileEvent 数组，大小为 setsize 。
loop->fired : 是一个aeFiredEvent 数组，大小也为 setsize 。
loop->timeEventHead ：目前为NULL
loop->apidata：指向aeApiState，包含epfd和epoll_event数组。接着我们调用anetTcpServer返回了listen_fd，anetTcpServer我们在anet.c分析的时候再说，接下来重点是我们调用aeCreateFileEvent将listen_fd注册到epfd上的过程。
//ae.c
int aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask, aeFileProc *proc, void *clientData) {
if (fd >= eventLoop->setsize) {
errno = ERANGE;
return AE_ERR;
}
aeFileEvent *fe = &eventLoop->events[fd]; //利用fe指向eventLoop->events[listen_fd]
if (aeApiAddEvent(eventLoop, fd, mask) == -1) { //本质是调用epoll_ctl(epfd,EPOLL_CTL_ADD,fd,...);
return AE_ERR;
}
fe->mask |= mask; //如果fe->mask之前不是空，现在就相当于同时监控两个事件
if (mask & AE_READABLE) {
fe->rfileProc = proc; //说明proc是读操作的处理函数
}
if (mask & AE_WRITABLE) {
fe->wfileProc = proc; //说明proc是写操作的处理函数
}
fe->clientData = clientData; //让它们指向同一个client或者server实例
if (fd > eventLoop->maxfd) {
eventLoop->maxfd = fd; //如果新的fd大于maxfd，则更新maxfd
}
return AE_OK;
}
此时我们的整个EventLoop变成了下面这个样子：
可以看到：
1 ： loop->events[4].mask = 1 , 表示读，rfileProc 为 acceptTcpHandler。 因为它是listen_fd，负责接受连接。为什么是 4 呢？因为 3 已经作为 epfd 的文件描述符了。
2 ： 我们将 fd = 4 & EPOLLIN事件注册给了epfd。现在就等着来新的连接了，因为这样的话一旦检测到listen_fd上有数据可读，那就会调用acceptTcpHandler接受连接，这也是回掉机制的一种体现：我们现在已经给listen_fd注册了相应的回掉函数了，等着事件发生，然后去调用注册好的函数。我们继续往下走继续看这个过程：
二、aeProcessEvents & acceptTcpHandler
继续向下会进入aeMain，之后一直轮询调用aeProcessEvents，接下来我们分析下aeProcessEvents到底是怎么处理各类事件的：
//ae.c
int aeProcessEvents(aeEventLoop *eventLoop, int flags) {
int processed = 0, numevents;
/* Nothing to do? return ASAP */
if (!(flags & AE_TIME_EVENTS) && !(flags & AE_FILE_EVENTS)) {
//如果flags什么事件都没有监听，return 0
return 0;
}
/* Note that we want call select() even if there are no
* file events to process as long as we want to process time
* events, in order to sleep until the next time event is ready
* to fire. */
/* 注意，我们即使没有文件事件，但是仍然想调用select/epoll，让其阻塞直到我们想处理的
* 定时事件发生为止*/
if (eventLoop->maxfd != -1 || ((flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT))) {
//如果有定时事件处理
aeTimeEvent *shortest = NULL;
struct timeval tv, *tvp;
if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT)) {
// for 循环查找到最近需要发生的定时事件
shortest = aeSearchNearestTimer(eventLoop);
}
if (shortest) {
long now_sec, now_ms;
aeGetTime(&now_sec, &now_ms);
tvp = &tv;
/* How many milliseconds we need to wait for the next time event to fire? */
/* 计算我们需要等待的ms数，直到最近的定时事件发生*/
long long ms = (shortest->when_sec - now_sec) * 1000 + shortest->when_ms - now_ms;
if (ms > 0) {
//如果定时事件没有过期，计算出需要等待的时间，作为epoll_wait的第四个参数
tvp->tv_sec = ms / 1000;
tvp->tv_usec = (ms % 1000) * 1000;
} else {
//否则置为0,epoll_wait就不会阻塞
tvp->tv_sec = 0;
tvp->tv_usec = 0;
}
} else {
/* If we have to check for events but need to return
* ASAP because of AE_DONT_WAIT we need to set the timeout to zero */
/*如果没有找到定时事件 */
if (flags & AE_DONT_WAIT) { //设置了AE_DONT_WAIT操作，就不等
tv.tv_sec = tv.tv_usec = 0;
tvp = &tv;
} else { //否则就阻塞等待直到事件发生
/* Otherwise we can block */
tvp = NULL; /* wait forever */
}
}
numevents = aeApiPoll(eventLoop, tvp); //调用epoll_wait函数，返回需要处理的事件列表
for (int i = 0; i < numevents; i++) { //遍历依次处理loop->fired
aeFileEvent *fe = &eventLoop->events[eventLoop->fired[i].fd];
int mask = eventLoop->fired[i].mask;
int fd = eventLoop->fired[i].fd;
int rfired = 0;
/* note the fe->mask & mask & ... code: maybe an already processed
* event removed an element that fired and we still didn't
* processed, so we check if the event is still valid. */
if (fe->mask & mask & AE_READABLE) {
rfired = 1; //确保读或者写只执行一个
fe->rfileProc(eventLoop, fd, fe->clientData, mask); //执行读处理
}
if (fe->mask & mask & AE_WRITABLE) {
if (!rfired || fe->wfileProc != fe->rfileProc) {
fe->wfileProc(eventLoop, fd, fe->clientData, mask);
}
}
processed++;
}
}
/* Check time events */
/* 处理所有的时间事件 */
if (flags & AE_TIME_EVENTS) {
processed += processTimeEvents(eventLoop);
}
return processed; /* return the number of processed file/time events */
}
假设 listen_fd此时发生了事件，那一定是有新的连接过来，fe->rfileProc(eventLoop, fd, fe->clientData, mask) 就会使用 acceptTcpHandler接受连接：
static void acceptTcpHandler(aeEventLoop *loop, int fd, void *data, int mask)
{
char cip[64];
int cport;
server_t *server = (server_t *)data;
int cfd = anetTcpAccept(NULL, fd, cip, sizeof(cip), &cport); //调用accept接受连接
if (cfd != -1) {
printf("accepted ip %s:%d\n", cip, cport);
anetNonBlock(NULL, cfd); //设置socket非阻塞
anetEnableTcpNoDelay(NULL, cfd); //开启TcpNoDelay选项
client_t *client = alloc_client(); //申请一个新的客户端
if (!client) {
printf("alloc client error...close socket\n");
close(fd);
return;
}
client->loop = loop;
client->fd = cfd;
if (aeCreateFileEvent(loop, cfd, AE_READABLE, readEventHandler, client) == AE_ERR) {
//继续调用aeCreateFileEvent给新连接的fd注册可读事件，并且注册读函数readEventHandler
if (errno == ERANGE) {
// or use aeResizeSetSize(server->loop, cfd) modify this limit
printf("so many client, close new.");
} else {
printf("create socket readable event error, close it.");
}
free_client(client);
}
}
}
处理到这里，算是接受了一个连接，至于以后的读写操作，等到下次再分析～