Redis事件管理（一）

Redis统一的时间管理器，同时管理文件事件和定时器，

这个管理器的定义：

#if defined(__APPLE__)
#define HAVE_TASKINFO 1
#endif

/* Test for backtrace() */
#if defined(__APPLE__) || (defined(__linux__) && defined(__GLIBC__))
#define HAVE_BACKTRACE 1
#endif

/* Test for polling API */
#ifdef __linux__
#define HAVE_EPOLL 1
#endif

#if (defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6)) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined (__NetBSD__)
#define HAVE_KQUEUE 1
#endif

#ifdef __sun
#include <sys/feature_tests.h>
#ifdef _DTRACE_VERSION
#define HAVE_EVPORT 1
#endif
#endif

/*检查具体使用哪个时间模型，Redis支持四个事件模型*/
#ifdef HAVE_EVPORT
#include "ae_evport.c"
#else
    #ifdef HAVE_EPOLL
    #include "ae_epoll.c"
    #else
        #ifdef HAVE_KQUEUE
        #include "ae_kqueue.c"
        #else
        #include "ae_select.c"
        #endif
    #endif
#endif

#define AE_NONE 0 /*该状态表示事件中该位置没使用*/
#define AE_READABLE 1/*设置了读事件*/
#define AE_WRITABLE 2/*设置了写事件*/

#define AE_FILE_EVENTS 1/*需要监控文件的读事件*/
#define AE_TIME_EVENTS 2/*需要监控文件的写事件*/
#define AE_ALL_EVENTS (AE_FILE_EVENTS|AE_TIME_EVENTS)/*读写事件同事监控*/
#define AE_DONT_WAIT 4/*处理事件时是否设置延迟时间*/

定时器结构体和文件事件结构体

 /* File event structure */
 typedef struct aeFileEvent
 {
     int mask; /*需要监控的读写事件标志位*/
     aeFileProc *rfileProc;/*读写事件处理函数*/
     aeFileProc *wfileProc;
     void *clientData;/*事件参数*/
 } aeFileEvent;

 /* Time event structure */
 typedef struct aeTimeEvent
 {
     long long id; /*定时器事件的ID*/
     long when_sec; /*触发的秒*/
     long when_ms; /*触发的毫秒*/
     aeTimeProc *timeProc;/*指定处理函数*/
     aeEventFinalizerProc *finalizerProc;/*// 定时事件清理函数，当删除定时事件的时候会被调用*/
     void *clientData;
     struct aeTimeEvent *next;/*下一个定时器对象，整体采用链表维护，作者好像知道链表维护的效率不是很高，推荐使用跳表，为啥不推荐使用红黑树嘞。*/
 } aeTimeEvent;

事件管理器的定义，在结构体中维护了两个数组，一个存放设置的文件描述符和设置，一个存放经过检测，满足条件的文件描述符和对应的触发状态，在处理的时候直接处理

fired中的数据就好。

typedef struct aeEventLoop
{
    int maxfd;   /*事件管理器能管理的文件描述符的最大值*/
    int setsize; /*管理器能管理的文件描述符的个数*/
    long long timeEventNextId; /*定时器用的*/
    time_t lastTime;     /*定时器最后一次处理时间，定时器中用的，防止修改了系统时间，影响了定时器的判断。*/
    aeFileEvent *events; /*原始事件数组，这里面存放的是开始的文件事件，保存文件描述符，需要监控的事件等信息*/
    aeFiredEvent *fired; /*触发事件数组，这里面放的是经过系统判断，有对应事件发生的文件描述符的存放数组，和上面一样，都采用数组维护*/
    aeTimeEvent *timeEventHead;/*定时器链表*/
    int stop;/*该事件管理器是否有效*/
    void *apidata; /*因为事件管理器支持很多模型，每个模型都有自己的特殊数据格式，这个变量就是用来存储模型自己的数据，拿epoll举个例子,这个地方会存储aeApiState节点的信息*/
    aeBeforeSleepProc *beforesleep;
} aeEventLoop;

具体的接口函数：

 /*创建一个事件管理器，需要初始化文件事件，触发事件，定时器事件等，stop值默认为0，最大文件描述符值为-1，并将所有的文件描述符的监控事件类型设置为NULL。 */
 1 aeEventLoop *aeCreateEventLoop(int setsize)
 {
     aeEventLoop *eventLoop;
     int i;

     if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL)
         goto err;
     eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);/*给文件事件申请空间*/
     eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);
     if (eventLoop->events == NULL || eventLoop->fired == NULL)
         goto err;
     eventLoop->setsize = setsize;/*设置可处理的事件个数*/
     eventLoop->lastTime = time(NULL);
     eventLoop->timeEventHead = NULL;/*定时器链表初始化*/
     eventLoop->timeEventNextId = ;
     eventLoop->stop = ;/*设置停用表示为无效*/
     eventLoop->maxfd = -;/*设置最大文件描述符的初始化*/
     eventLoop->beforesleep = NULL;
     if (aeApiCreate(eventLoop) == -)
         goto err;
     /* Events with mask == AE_NONE are not set. So let's initialize the
      * vector with it. */
     for (i = ; i < setsize; i++)
         eventLoop->events[i].mask = AE_NONE;/*AE_NONE代表这个事件没有启用*/
     return eventLoop;

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

/*返回管理器能管理的事件的个数*/
int aeGetSetSize(aeEventLoop *eventLoop)
{
    return eventLoop->setsize;
}

 /*重置管理器能管理的事件个数*/
 int aeResizeSetSize(aeEventLoop *eventLoop, int setsize)
 {
     int i;
     /*如果新大小等于现有的大小则直接返回成*/
     if (setsize == eventLoop->setsize)
         return AE_OK;
     /*如果重置的大小小于当前管理器中最大的文件描述符大小，则不能进行重置，否则会丢失已经注册的事件。*/
     if (eventLoop->maxfd >= setsize)
         return AE_ERR;
     /*调用已经封装好的重置大小函数*/
     if (aeApiResize(eventLoop,setsize) == -)
         return AE_ERR;
     /*重置记录内存块大小*/
     eventLoop->events = zrealloc(eventLoop->events,sizeof(aeFileEvent)*setsize);
     eventLoop->fired = zrealloc(eventLoop->fired,sizeof(aeFiredEvent)*setsize);
     eventLoop->setsize = setsize;

     /*将新增部分的事件标记置为无效*/
     for (i = eventLoop->maxfd+; i < setsize; i++)
         eventLoop->events[i].mask = AE_NONE;
     return AE_OK;
 }

 /*删除事件控制器*/
 void aeDeleteEventLoop(aeEventLoop *eventLoop)
 {
     /*调用封装好的删除事件函数*/
     aeApiFree(eventLoop);
     /*逐个释放内存*/
     zfree(eventLoop->events);
     zfree(eventLoop->fired);
     zfree(eventLoop);
 }

/*增加一个文件事件，参数为事件控制器，文件描述符，事件掩码，处理函数，函数参数，对一个描述符添加多个事件的时候要挨个添加*/
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) == -)
        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)/*更新文件最大描述符*/
        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;

     /*先把事件从处理模型中去掉*/
     aeApiDelEvent(eventLoop, fd, mask);
     fe->mask = fe->mask & (~mask);/*去掉读写掩码*/
     /*检查是否需要更新管理器中的最大文件描述符的值*/
     if (fd == eventLoop->maxfd && fe->mask == AE_NONE)
     {
         /* Update the max fd */
         int j;
         /*从最大位置反向找启用的位置，更新最大文件描述符*/
         for (j = eventLoop->maxfd-; j >= ; j--)
             if (eventLoop->events[j].mask != AE_NONE) break;
         eventLoop->maxfd = j;
     }
 }

/*获取某个文件描述符的注册事件*/
int aeGetFileEvents(aeEventLoop *eventLoop, int fd)
{
    if (fd >= eventLoop->setsize) return ;
    aeFileEvent *fe = &eventLoop->events[fd];

    return fe->mask;
}

 /*处理控制器中的所有时间，算是最核心的函数了，参数2为要处理的事件类型*/
 int aeProcessEvents(aeEventLoop *eventLoop, int flags)
 {
     int processed = , numevents;

     /*参数2设置的是不处理任何事件就直接返回*/
     if (!(flags & AE_TIME_EVENTS) && !(flags & AE_FILE_EVENTS))
         return ;

     /* 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. */
     if (eventLoop->maxfd != - || ((flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT)))
     {
         int j;
         aeTimeEvent *shortest = NULL;
         struct timeval tv, *tvp;

         /*处理文件时间事件，先检查是否需要设置延时时间，
         延时时间的计算方法，如果有定时器事件，就设定定时器事件里面距离触发事件最近的时间?
         否则设置成NULL，无限期等待。*/
         if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT))
             shortest = aeSearchNearestTimer(eventLoop);
         if (shortest)
         {
             long now_sec, now_ms;

             /* Calculate the time missing for the nearest
              * timer to fire. */
             aeGetTime(&now_sec, &now_ms);
             tvp = &tv;
             tvp->tv_sec = shortest->when_sec - now_sec;
             if (shortest->when_ms < now_ms)
             {
                 tvp->tv_usec = ((shortest->when_ms+) - now_ms)*;
                 tvp->tv_sec --;
             }
             else
             {
                 tvp->tv_usec = (shortest->when_ms - now_ms)*;
             }
             if (tvp->tv_sec < ) tvp->tv_sec = ;
             if (tvp->tv_usec < ) tvp->tv_usec = ;
         }
         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)
             {
                 tv.tv_sec = tv.tv_usec = ;
                 tvp = &tv;
             }
             else
             {
                 /* Otherwise we can block */
                 tvp = NULL; /* wait forever */
             }
         }

         /*调用统一的事件监控接口，并处理*/
         numevents = aeApiPoll(eventLoop, tvp);
         for (j = ; j < numevents; j++)
         {
             aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];
             int mask = eventLoop->fired[j].mask;
             int fd = eventLoop->fired[j].fd;
             int rfired = ;

             /* 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 = ;
                 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++;
         }
     }
     /*检查处理定时器事件*/
     if (flags & AE_TIME_EVENTS)
         processed += processTimeEvents(eventLoop);

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

 /*事件管理器总函数，没啥可说的*/
 void aeMain(aeEventLoop *eventLoop)
 {
     eventLoop->stop = ;
     while (!eventLoop->stop)
     {
         if (eventLoop->beforesleep != NULL)
             eventLoop->beforesleep(eventLoop);
         aeProcessEvents(eventLoop, AE_ALL_EVENTS);
     }
 }