Redis源码(1) 建立监听服务和开启事件循环

Redis 是cs架构(服务端-客户端)，典型的一对多的服务器应用程序。多个客户通过网络与Redis服务器进行通信。那么在linux环境中是使用epoll(我们也 只讨论linux环境的，便于学习)。
　　通过使用I/O多路复用技术， redis 服务器使用单线程单进程的方式处理命令请求，并与多个客户端连接进行网络通讯。

redis的网络框架和Muduo是很相似的，若是弄懂了Muduo后在来看Redis的网络部分，那是很轻松的。这里推荐下我写的cppServer程序，有很详细的章节解说。0.仿造muduo,实现linux服务器开发思路

 看懂这个后，很有助于看懂Muduo和Redis的网络部分。

1.Redis的main()函数-----建立监听的开始

//server.c
int main(int argc, char **argv) {
   
	//省略很多.......
	
    initServer();

	//省略很多.......
	
	//server.el 类型是struct aeEventLoop*
    aeMain(server.el);
    aeDeleteEventLoop(server.el);
	
    return 0;
}

目前，main()函数中关于网络的主要就这几个函数，其他的先省略了。

而要介绍这几个函数，需要先介绍一些数据结构才行。

2.网络相关的数据结构

这里就介绍aeEventLoop,aeFileEvent，aeTimeEvent，aeFiredEvent4个结构体(都在ae.h文件中)。

aeEventLoop是重中之重，带出其他三个结构体。

1.struct aeEventLoop

这个就类似我写的程序里面的EventLoop。

aeEventLoop是Reactor模型的具体抽象，把网络读写事件和时间事件(定时器任务)可以统一到一起处理。

• events实际是个大小为setsize的数组，管理着网络IO事件。events数组的下标表示的是fd,而对应的元素是该fd关注的IO事件(aeFileEvent结构体)。
• fired数组是已被触发读写的网络事件数组。其下标仅仅是索引index,该索引位置上的元素是记录了被触发的fd及其对应的事件类型。

• 在Redis中是使用链表存储定时器任务的。timeEventHead表示的是定时器链表的头结点。而由于每次定时器任务结点都是从链表头部插入的，所以timeEventHead记录的是最晚插入的结点。（因为是直接插入放在头结点，所有对链表进行排序，所以头结点不一定是最早超时的任务）

• beforesleep和aftersleep是每次事件循坏之前和之后需要执行的回调函数。(即是调用epoll_wait()前后）

• apidata封装来具体的IO多路复用的系统调用。linux主要有select、poll、epoll，在Redis代码文件中分别对应ae.select.cc、ae_evport.cc、ae_epoll.cc。(这里我们只分析epoll)。

//ae.h
// 事件循环
typedef struct aeEventLoop {
    int maxfd;       //目前已注册的最大文件描述符fd
    int setsize;     //能注册的最大描述符数
    long long timeEventNextId;    //下一个要注册的时间事件id

    time_t lastTime;      //最后一次执行时间事件的时间
    aeFileEvent *events;     //是数组，已注册的文件事件 (就是IO event)
    aeFiredEvent *fired;     //数组，已就绪的文件事件

    aeTimeEvent *timeEventHead;    //定时器链表的头结点

    int stop;    //eventLoop的开关
    
    void *apidata; //多路复用库的私有数据(epollfd相关的数据)
    aeBeforeSleepProc *beforesleep;//在处理事件前要执行的回调函数(即是在执行epoll_wait()之前)
    aeBeforeSleepProc *aftersleep;//在处理事件后要执行的回调函数(即是在执行epoll_wait()之后)
    int flags;          //设置的标识位
} aeEventLoop;


//文件事件结构
typedef struct aeFileEvent {
    //监听事件类型，即是关注的事件
    int mask; /* one of AE_(READABLE|WRITABLE|BARRIER) */
    aeFileProc *rfileProc;      //读事件的回调函数
    aeFileProc *wfileProc;      //写事件的回调函数
    void *clientData;           
} aeFileEvent;

//已就绪的事件
typedef struct aeFiredEvent {
    int fd;     //已就绪文件描述符
    int mask;   //事件类型
} aeFiredEvent;

2.aeFileEvent用来管理要注册的IO事件

• mask是需要注册的事件类型。其就是这几个事件经过或运算后的掩码，包括AE_READABLE（可读事件）、AE_WRITABLE（可写事件）和AE_BARRIER（该事件可以实现读写事件处理顺序的反转)。(AE_BARRIER可以先不了解，没有影响的)
• clientData是万能指针void*,是执行回调处理函数的参数数据。
• rfileProc和wfileProc是回调函数，分别在AE_READABLE和AE_WRITABLE类型时进行回调使用的。

 要说说回调函数的类型。

//ae.h
//回调函数类型
//用c++11表示的话 using aeFileProc=std::function;

//IO读写事件回调函数
typedef void aeFileProc(struct aeEventLoop *eventLoop, int fd, void *clientData, int mask);
//定时器事件回调函数
typedef int aeTimeProc(struct aeEventLoop *eventLoop, long long id, void *clientData);
//删除定时事件的回调函数
typedef void aeEventFinalizerProc(struct aeEventLoop *eventLoop, void *clientData);
//进入循环等待之前的回调函数
typedef void aeBeforeSleepProc(struct aeEventLoop *eventLoop);

 3.aeFiredEvent用来管理已经发生的IO事件

• fd是已事件就绪的文件描述符
• mask是返回的已发生事件的事件类型（通过epoll_wait()返回已发生的事件）

 4.时间事件是aeTimeEvent，timeEventHead是注册的时间事件列表(链表)

• 每个时间事件都有一个事件id，aeEventLoop中的timeEventNextId是下一个要注册的时间事件id。
• when_sec、when_ms是时间事件(定时器任务)的发生时间
• timeProc是时间事件的处理回调函数。说明：aeTimeProc 需要返回一个 int 值，代表下次该超时事件触发的时间间隔。如果返回 - 1，则说明超时时间不需要再触发了，标记为删除即可
• finalizerProc是时间事件要删除时的处理函数

//ae.h
//时间事件结构
typedef struct aeTimeEvent {
    long long id; //时间事件的唯一标识符，自增

    //事件的到达时间(即是执行时间)
    long when_sec; /* seconds */
    long when_ms; /* milliseconds */

    //事件处理函数 (到期执行的回调函数)
    aeTimeProc *timeProc;

    //事件释放函数 (回调函数)
    aeEventFinalizerProc *finalizerProc;
    void *clientData;               //多路复用库的私有数据
    //双向链表
    struct aeTimeEvent *prev;   
    struct aeTimeEvent *next;
    int refcount;     //以防止计时器事件在递归时间事件调用中释放
} aeTimeEvent;

那么，我们接着看回main()函数中的关于网络的部分。

initServer()函数

void initServer(void) {
	//省略了很多不相关的代码.......
	//创建evEventLoop ,也可以说是创建epoll
    //server.el是aeEventLoop*类型
	server.el = aeCreateEventLoop(server.maxclients+CONFIG_FDSET_INCR);

    //ipfd是服务器端fd,是数组，因为有IPV4和IPV4,
    listenToPort(server.port,server.ipfd,&server.ipfd_count);//函数内部调用sokcet(),bind(),listen()...
		
    for (j = 0; j < server.ipfd_count; j++) {
        aeCreateFileEvent(server.el, server.ipfd[j], AE_READABLE,
            acceptTcpHandler,NULL);

    }
}

3.事件驱动初始化

1.aeCreateEventLoop()函数，创建EventLoop。

其主要4步：

1.分配内存给eventloop;

2.eventloop的成员进行初始化，

3.创建epollfd(调用epoll_create());

4.初始化要关注的事件类型，初始化阶段什么时间也没有关注。

aeEventLoop *aeCreateEventLoop(int setsize) {
    aeEventLoop *eventLoop;
    int i;

    //1.分配内存  zmalloc()函数是Redis封装的函数，可以理解为是malloc()
    if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL) goto err;
    //创建数组，可见数组的长度就是setsize
    eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);
    eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);
    if (eventLoop->events == NULL || eventLoop->fired == NULL) goto err;
    //2.初始化
    eventLoop->setsize = setsize;
    eventLoop->lastTime = time(NULL);
    eventLoop->timeEventHead = NULL;
    eventLoop->timeEventNextId = 0;
    eventLoop->stop = 0;
    eventLoop->maxfd = -1;
    eventLoop->beforesleep = NULL;
    eventLoop->aftersleep = NULL;
    eventLoop->flags = 0;
    //3.创建epollfd
    if (aeApiCreate(eventLoop) == -1) goto err;
    /* Events with mask == AE_NONE are not set. So let's initialize the
     * vector with it. */
    /*
    * 可以看到数组长度就是setsize，同时创建之后将每一个event的mask属性置为AE_NONE(即是0)，
    *对于eventLoop->events数组来说，fd就是这个数组的下标。
    *例如，当程序刚刚启动时候，创建监听套接字，按照标准规定，该fd的值为3。此时就直接在            
     eventLoop->events下标为3的元素中存放相应event数据。
    *不过也基于文件描述符的这些特点，意味着events数组的前三位一定不会有相应的fd赋值。
    */
    //4.初始化，什么事件也没有关注，mask=AE_NONE
    for (i = 0; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;
    return eventLoop;

err:
    if (eventLoop) {
        zfree(eventLoop->events);
        zfree(eventLoop->fired);
        zfree(eventLoop);
    }
    return NULL;
}

2.IO多路复用，epoll的封装

 epoll的封装都在ae_epoll.c文件中。这个是封装了I/O多路复用。

主要是封装一些epoll的函数(epoll_create,epoll_ctl)。  

aeEventLoop中的apidata在epoll中表示为aeApiState。结构体aeApiState中的epfd为epoll的fd，events表示接受事件循环epoll_wait返回的触发读写的网络事件。

• int aeApiCreate(aeEventLoop *eventLoop):   

 调用epoll_create()得到epfd，并将aeApiState数据赋值给eventLoop->apidata。 

• int aeApiResize(aeEventLoop *eventLoop, int setsize):

         重置eventLoop->apidata的events的大小。

• int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask):

        调用epeoll_ctl()，根据mask对fd进行添加或修改。

• void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int delmask)：

         调用epoll_ctl(),对fd进行删除。

•  int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp)：

         调用epoll_wait(),得到已就绪的events，并将已就绪的events赋值给eventLoop->fired。

//ae_epoll.c
typedef struct aeApiState {
    int epfd;        //这个是epoll_create()返回来的fd
    struct epoll_event *events; //用在epoll_wait(int epfd,epoll_event* events)函数内的参数
} aeApiState;

//创建epollfd，调用epoll_create()
static int aeApiCreate(aeEventLoop *eventLoop) {
    aeApiState *state = zmalloc(sizeof(aeApiState));

    if (!state) return -1;
    state->events = zmalloc(sizeof(struct epoll_event)*eventLoop->setsize);
    if (!state->events) {
        zfree(state);
        return -1;
    }
    state->epfd = epoll_create(1024); /* 1024 is just a hint for the kernel */
    if (state->epfd == -1) {
        zfree(state->events);
        zfree(state);
        return -1;
    }
    eventLoop->apidata = state;//epoll的数据aeApiState
    return 0;
}

//重置events的大小
static int aeApiResize(aeEventLoop *eventLoop, int setsize) {
    aeApiState *state = eventLoop->apidata;

    state->events = zrealloc(state->events, sizeof(struct epoll_event)*setsize);
    return 0;
}

//添加fd到epoll上，调用epoll_ctl()
static int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask) {
    aeApiState *state = eventLoop->apidata;
    struct epoll_event ee = {0}; /* avoid valgrind warning */
    /* If the fd was already monitored for some event, we need a MOD
     * operation. Otherwise we need an ADD operation. */
    int op = eventLoop->events[fd].mask == AE_NONE ?
            EPOLL_CTL_ADD : EPOLL_CTL_MOD;

    ee.events = 0;
    mask |= eventLoop->events[fd].mask; /* Merge old events */
    if (mask & AE_READABLE) ee.events |= EPOLLIN;
    if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;
    ee.data.fd = fd;
    if (epoll_ctl(state->epfd,op,fd,&ee) == -1) return -1;
    return 0;
}

static void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int delmask) {
    aeApiState *state = eventLoop->apidata;
    struct epoll_event ee = {0}; /* avoid valgrind warning */
    int mask = eventLoop->events[fd].mask & (~delmask);

    ee.events = 0;
    if (mask & AE_READABLE) ee.events |= EPOLLIN;
    if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;
    ee.data.fd = fd;
    if (mask != AE_NONE) {
        epoll_ctl(state->epfd,EPOLL_CTL_MOD,fd,&ee);
    } else {
        /* Note, Kernel < 2.6.9 requires a non null event pointer even for
         * EPOLL_CTL_DEL. */
        epoll_ctl(state->epfd,EPOLL_CTL_DEL,fd,&ee);
    }
}

static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {
    aeApiState *state = eventLoop->apidata;
    int retval, numevents = 0;

    retval = epoll_wait(state->epfd,state->events,eventLoop->setsize,
            tvp ? (tvp->tv_sec*1000 + tvp->tv_usec/1000) : -1);
    if (retval > 0) {
        int j;

        numevents = retval;
        for (j = 0; j < numevents; j++) {
            int mask = 0;
            struct epoll_event *e = state->events+j;

            if (e->events & EPOLLIN) mask |= AE_READABLE;
            if (e->events & EPOLLOUT) mask |= AE_WRITABLE;
            if (e->events & EPOLLERR) mask |= AE_WRITABLE|AE_READABLE;
            if (e->events & EPOLLHUP) mask |= AE_WRITABLE|AE_READABLE;
            //赋给已就绪的fired事件
            eventLoop->fired[j].fd = e->data.fd;
            eventLoop->fired[j].mask = mask;
        }
    }
    return numevents;
}

创建好EventLoop后，需要进行服务器的初始化，调用socket(),bind()等等操作。

4.listenToPort函数,进行服务器的常规初始化操作(socket,bind,listen)

bindaddr是个元素是char*的数组，元素是服务器需要绑定的ip。

为了便于分析，假定server.bindaddr_count是0,那么IPv4和IPv6都需要绑定。

//in server.c
//调用例子 listenToPort(server.port,server.ipfd,&server.ipfd_count)
int listenToPort(int port, int *fds, int *count) {
	int j;
    if (server.bindaddr_count == 0) server.bindaddr[0] = NULL;
    for (j = 0; j < server.bindaddr_count || j == 0; j++) {
        if (server.bindaddr[j] == NULL) {
            /* Bind * for both IPv6 and IPv4, we enter here only if
             * server.bindaddr_count == 0. */
            fds[*count] = anetTcp6Server(server.neterr,port,NULL,
                server.tcp_backlog);
            if (fds[*count] != ANET_ERR) {
                anetNonBlock(NULL,fds[*count]);    //设置非阻塞
                (*count)++;
            } 

            if (*count == 1) {
                /* Bind the IPv4 address as well. */
                fds[*count] = anetTcpServer(server.neterr,port,NULL,
                    server.tcp_backlog);
                if (fds[*count] != ANET_ERR) {
                    anetNonBlock(NULL,fds[*count]);
                    (*count)++;
                } 
            }

        } 
        if (fds[*count] == ANET_ERR) {
			//省略一些错误处理和打印日志
            return C_ERR;
        }
        anetNonBlock(NULL,fds[*count]);
        (*count)++;
    }
    return C_OK;
}

 这里需要调用anetTcpServer()函数和anetTcp6Server()函数。

//in anet.c
int anetTcpServer(char *err, int port, char *bindaddr, int backlog)
{
    return _anetTcpServer(err, port, bindaddr, AF_INET, backlog);
}

int anetTcp6Server(char *err, int port, char *bindaddr, int backlog)
{
    return _anetTcpServer(err, port, bindaddr, AF_INET6, backlog);
}

static int _anetTcpServer(char *err, int port, char *bindaddr, int af, int backlog)
{
    int s = -1, rv;
    char _port[6];  /* strlen("65535") */
    struct addrinfo hints, *servinfo, *p;

    snprintf(_port,6,"%d",port);
    memset(&hints,0,sizeof(hints));
    hints.ai_family = af;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE;    /* No effect if bindaddr != NULL */

    if ((rv = getaddrinfo(bindaddr,_port,&hints,&servinfo)) != 0) {
        anetSetError(err, "%s", gai_strerror(rv));
        return ANET_ERR;
    }
    
    /* getaddrinfo() returns a list of address structures.
        Try each address until we successfully bind(2).
        If socket(2) (or bind(2)) fails, we (close the socket
        and) try the next address. */

    //其中有绑定一个成功就会跳出for循环的
    for (p = servinfo; p != NULL; p = p->ai_next) {
        if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1) //创建sockdfd
            continue;

        if (af == AF_INET6 && anetV6Only(err,s) == ANET_ERR) goto error;
        if (anetSetReuseAddr(err,s) == ANET_ERR) goto error;    //设置端口服用
        if (anetListen(err,s,p->ai_addr,p->ai_addrlen,backlog) == ANET_ERR) s = ANET_ERR;   //绑定并开始监听
        goto end;
    }
    if (p == NULL) {
        anetSetError(err, "unable to bind socket, errno: %d", errno);
        goto error;
    }

error:
    if (s != -1) close(s);
    s = ANET_ERR;
end:
    freeaddrinfo(servinfo);
    return s;
}

5.创建服务器的FileEvent，并注册到eventLoop中

绑定并进行listenn()监听后，就到了aeCreateFileEvent(),进行事件注册，添加FileEvent到eventLoop中。

事件一共有两类：

• IO事件注册与删除：aeCreateFileEvent，aeDeleteFileEvent
• 时间事件注册与删除：aeCreateTimeEvent，aeDeleteTimeEvent

 IO事件的注册通过aeApiAddEvent函数将套接字及其事件处理函数注册到epoll中。

//in ae.c
//根据mask参数的值， 创建文件事件
// 监听fd 文件的状态，
//当fd可用时，执行proc函数(即是回调函数)
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];

    if (aeApiAddEvent(eventLoop, fd, mask) == -1)//使用epoll的话即是调用epoll_ctl
        return AE_ERR;

    //设置文件事件类型，以及事件的处理器(即是设置回调函数)
    fe->mask |= mask;
    if (mask & AE_READABLE) fe->rfileProc = proc;
    if (mask & AE_WRITABLE) fe->wfileProc = proc;
    fe->clientData = clientData;
    if (fd > eventLoop->maxfd)  //若符合，则更新maxfd
        eventLoop->maxfd = fd;
    return AE_OK;
}

void aeDeleteFileEvent(aeEventLoop *eventLoop, int fd, int mask)
{
    if (fd >= eventLoop->setsize) return;
    aeFileEvent *fe = &eventLoop->events[fd];
    if (fe->mask == AE_NONE) return;

    /* We want to always remove AE_BARRIER if set when AE_WRITABLE
     * is removed. */
    if (mask & AE_WRITABLE) mask |= AE_BARRIER;

    aeApiDelEvent(eventLoop, fd, mask); //调用epoll_ctlr(del)
    fe->mask = fe->mask & (~mask);
    if (fd == eventLoop->maxfd && fe->mask == AE_NONE) {
        /* Update the max fd */
        int j;

        for (j = eventLoop->maxfd-1; j >= 0; j--)   //判断最大的fd的mask
            if (eventLoop->events[j].mask != AE_NONE) break;
        eventLoop->maxfd = j;
    }
}

//创建时间事件
long long aeCreateTimeEvent(aeEventLoop *eventLoop, long long milliseconds,
        aeTimeProc *proc, void *clientData,
        aeEventFinalizerProc *finalizerProc)
{
    long long id = eventLoop->timeEventNextId++;    //更新时间计数器，这个id是时间事件的唯一标识符
    aeTimeEvent *te;

    te = zmalloc(sizeof(*te));
    if (te == NULL) return AE_ERR;
    te->id = id;
    aeAddMillisecondsToNow(milliseconds,&te->when_sec,&te->when_ms);    //设置到期时间
    //设置事件处理器，即是设置回调函数
    te->timeProc = proc;
    te->finalizerProc = finalizerProc;
    //设置私有数据
    te->clientData = clientData;
    te->prev = NULL;
    te->next = eventLoop->timeEventHead;    //将新事件放入表头
    te->refcount = 0;
    if (te->next)
        te->next->prev = te;
    eventLoop->timeEventHead = te;
    return id;
}

int aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id)
{
    aeTimeEvent *te = eventLoop->timeEventHead; //这是个链表
    while(te) { //需要从头找到尾
        if (te->id == id) {
            te->id = AE_DELETED_EVENT_ID;
            return AE_OK;
        }
        te = te->next;
    }
    return AE_ERR; /* NO event with the specified ID found */
}

那么现在，通过 aeCreateFileEvent(server.el,server.ipfd[j],AE_READABLE,acceptTcpHandler,NULL);将服务器的监听fd和其事件回调函数acceptTcpHandler注册到epoll中，并监听读事件。(acceptTcpHandler函数先不细讲，这个函数肯定是有调用accept()的)

6.进行事件循环

启动aeMain函数阻塞等待事件发生，并处理。

//文件事件 1
#define AE_FILE_EVENTS (1<<0)
//时间事件 2
#define AE_TIME_EVENTS (1<<1)
//文件事件和时间事件 4
#define AE_ALL_EVENTS (AE_FILE_EVENTS|AE_TIME_EVENTS)
//不阻塞等待标识 8
#define AE_DONT_WAIT (1<<2)

#define AE_CALL_BEFORE_SLEEP (1<<3)
#define AE_CALL_AFTER_SLEEP (1<<4)

void aeMain(aeEventLoop *eventLoop) {
    eventLoop->stop = 0;
    while (!eventLoop->stop) {
        aeProcessEvents(eventLoop, AE_ALL_EVENTS|
                                   AE_CALL_BEFORE_SLEEP|
                                   AE_CALL_AFTER_SLEEP);
    }
}

该函数就是一个while()循环，循环内部是aeProcessEvents函数。

下面注重来看下aeProcessEvents，第一个参数是要处理的事件驱动框架，第二个参数是要处理的事件类型，在aeMain中表示处理包括IO事件和时间事件在内的所有事件以及回调前置函数beforesleep和回调后置函数aftersleep。

aeProcessEvents的主要步骤：

回调函数beforsleep和aftersleep可以先省略不关注的。因为目前其还没有用途，先知道有这两个回调函数就行。

1.计算epoll_wait()需要的阻塞时间。

        如果是设置了AF_DONT_WAIT,那就是不阻塞，epoll_wait()的超时时间就设置为0。如有定时器任务，那么其阻塞时间即是定时器的最早超时时间，这样可以防止定时器任务等待过久。

若是没有定时器任务，那就永远等待下去，直到有事件被触发。

2.执行beforsleep

        在epoll_wait()阻塞之前执行一些任务，防止因为阻塞时间过长而无法执行，或者执行一些准备工作。

3.epoll_wait等待事件发生。

4.执行aftersleep。

5.处理发生的IO事件。

根据发生的事件类型来调用对应的回调函数。若是AE_READABLE类型调用rfileProc，若是AE_WRITABLE类型调用wfileProc。一般来说，先处理AE_READABLE类型事件，该类事件一般为客户端连接或者命令，然后处理AE_WRITABLE类型事件向客户端发送响应对于客户端的回复，一般在beforesleep中就会执行完成）

6.处理时间事件。若该时间事件时周期性的，执行完后会再添加到时间事件链表的。

int aeProcessEvents(aeEventLoop *eventLoop, int flags)
{
    int processed = 0, numevents;

    //没有时间事件和文件事件，退出
    if (!(flags & AE_TIME_EVENTS) && !(flags & AE_FILE_EVENTS)) return 0;


    //1.计算epoll_wait()需要的阻塞时间
    if (eventLoop->maxfd != -1 ||
        ((flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT))) {
        int j;
        aeTimeEvent *shortest = NULL;
        struct timeval tv, *tvp;

        if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT)) //表示有时间事件且需要阻塞，epoll_wait()设置的时间就不是0
            shortest = aeSearchNearestTimer(eventLoop); //找到最近的定时器超时时间
        if (shortest) {
            long now_sec, now_ms;

            aeGetTime(&now_sec, &now_ms);
            tvp = &tv;

            //定时器的到期时间,毫秒数
            long long ms =
                (shortest->when_sec - now_sec)*1000 +
                shortest->when_ms - now_ms;

            if (ms > 0) {
                tvp->tv_sec = ms/1000;
                tvp->tv_usec = (ms % 1000)*1000;
            } else {
                tvp->tv_sec = 0;
                tvp->tv_usec = 0;
            }
        } else {
            //不需要阻塞
            if (flags & AE_DONT_WAIT) {
                tv.tv_sec = tv.tv_usec = 0;
                tvp = &tv;
            } else {
                /* Otherwise we can block */
                tvp = NULL; /* wait forever */
            }
        }
        //再次确认
        if (eventLoop->flags & AE_DONT_WAIT) {
            tv.tv_sec = tv.tv_usec = 0;
            tvp = &tv;
        }

        //2.执行beforesleep
        if (eventLoop->beforesleep != NULL && flags & AE_CALL_BEFORE_SLEEP)
            eventLoop->beforesleep(eventLoop);  //在休眠前执行（即是在epoll_wait()前)

        /* Call the multiplexing API, will return only on timeout or when
         * some event fires. */
        //3.执行epoll_wait
        numevents = aeApiPoll(eventLoop, tvp);

        //4.执行aftersleep
        /* After sleep callback. */
        if (eventLoop->aftersleep != NULL && flags & AE_CALL_AFTER_SLEEP)
            eventLoop->aftersleep(eventLoop);//在休眠后执行（即是在epoll_wait()之后)

        //5.逐个处理触发的事件
        for (j = 0; j < numevents; j++) {
            aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];
            int mask = eventLoop->fired[j].mask;        //这个是epoll_wait()返回的触发事件类型
            int fd = eventLoop->fired[j].fd;
            int fired = 0; /* Number of events fired for current fd. */

            int invert = fe->mask & AE_BARRIER;


            //触发可读事件
            if (!invert && fe->mask & mask & AE_READABLE) {
                fe->rfileProc(eventLoop,fd,fe->clientData,mask);
                fired++;
                fe = &eventLoop->events[fd]; /* Refresh in case of resize. */
            }

            //可写事件
            if (fe->mask & mask & AE_WRITABLE) {
                if (!fired || fe->wfileProc != fe->rfileProc) {
                    fe->wfileProc(eventLoop,fd,fe->clientData,mask);
                    fired++;
                }
            }

            /* If we have to invert the call, fire the readable event now
             * after the writable one. */
            if (invert) {
                fe = &eventLoop->events[fd]; /* Refresh in case of resize. */
                if ((fe->mask & mask & AE_READABLE) &&
                    (!fired || fe->wfileProc != fe->rfileProc))
                {
                    fe->rfileProc(eventLoop,fd,fe->clientData,mask);
                    fired++;
                }
            }

            processed++;
        }
    }

    //6.处理时间事件
    if (flags & AE_TIME_EVENTS)
        processed += processTimeEvents(eventLoop);  

    return processed; /* return the number of processed file/time events */
}