Redis中的事件迴圈是他的ae模組（advance eventloop？），這是個簡單的事件迴圈模組，自身實現了事件迴圈框架和時間事件邏輯，而具體事件處理則根據不同的系統編譯不同的模組。ae主要由這幾個模組組成：

• ae.c
• ae.h
• ae_epoll.c
• ae_evport.c
• ae_kqueue.c
• ae_select.c

可以看出來，ae實現了epoll，evport，kqueue和select模型幾種，需要設定引數來配置具體的模組，關於這幾種事件模型原理這裡就不細說了，本文僅以epoll來說。

/* Include the best multiplexing layer supported by this system.
 - The following should be ordered by performances, descending. */
 

#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

所有epoll事件均是以陣列元素的形式新增到陣列中，fd作為陣列索引，整個事件迴圈框架會維護兩個陣列：註冊事件陣列和觸發事件陣列，在poll時會把註冊事件中完成的事件新增到觸發事件陣列中。而時間事件則是一個單向連結串列：

/* State of an event based program */
typedef struct aeEventLoop {
    ...
    //註冊的可以被epoll觸發的事件陣列
    aeFileEvent *events; /* Registered events */
    //已經觸發的epoll事件陣列
    aeFiredEvent *fired; /* Fired events */
    //時間事件連結串列，利用epoll超時時間來實現
    aeTimeEvent *timeEventHead;
    ...
} aeEventLoop;

typedef struct aeApiState {
    int epfd;
    //epoll內部陣列，用於接收以觸發事件陣列
    struct epoll_event *events;
} aeApiState;
 

這樣在新增新的事件時就需要把fd，屬性，回撥以及回撥引數等分別新增到這些陣列中。

aeFileEvent *fe = &eventLoop->events[fd];
//新增到epoll
if (aeApiAddEvent(eventLoop, fd, mask) == -1)
    return AE_ERR;
fe->mask |= mask;
if (mask & AE_READABLE) fe->rfileProc = proc;
if (mask & AE_WRITABLE) fe->wfileProc = proc;
fe->clientData = clientData;
//設定最大fd
if (fd > eventLoop->maxfd)
    eventLoop->maxfd = fd;

而對於時間事件，則只是簡單的新增到時間佇列中：

aeTimeEvent *te;

te = zmalloc(sizeof(*te));
...
te->next = eventLoop->timeEventHead;
eventLoop->timeEventHead = te;

ae框架中還有兩個回撥，一個是在一次事件處理前執行，一個是在事件處理後執行，這樣使用者就有足夠的自由度來處理一些自己的事情。：

/* State of an event based program */
typedef struct aeEventLoop {
    ......
    aeBeforeSleepProc *beforesleep;
    aeBeforeSleepProc *aftersleep;
} aeEventLoop;

在Redis中，預處理回撥（beforesleep）會在每次進入事件前：

• 檢查是否停止事件迴圈。
• 快速的檢查並清理超時鍵值對。
• 向從伺服器傳送ACK請求。
• 處理上一輪迴圈中阻塞的請求。
• 寫入aof檔案。
• 將傳送給client的緩衝區傳送掉。

完成這些後，ae將進入下一輪事件迴圈。

eventLoop->stop = 0;
while (!eventLoop->stop) {
if (eventLoop->beforesleep != NULL)
     eventLoop->beforesleep(eventLoop);
     aeProcessEvents(eventLoop, AE_ALL_EVENTS|AE_CALL_AFTER_SLEEP);
}

處理迴圈時，首先會在時間事件中找到離現在（now）的最近的待觸發時間事件，並將到這個事件所需的時間設定為epoll的超時時間，這樣epoll一旦超時，意味著剛剛找到的時間事件需要處理了。

        aeTimeEvent *shortest = NULL;
        struct timeval tv, *tvp;

        //找到最近的時間事件
        if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT))
            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? */
            long long ms =
                (shortest->when_sec - now_sec)*1000 +
                shortest->when_ms - now_ms;

            //如果差值小於0，那應該有個時間事件已經過了，應該趕緊處理
            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 we have to check for events but need to return
             * ASAP because of AE_DONT_WAIT we need to set the timeout
             * to zero */
            //如果需要一直阻塞就直接設定NULL，否則超時時間0
            if (flags & AE_DONT_WAIT) {
                tv.tv_sec = tv.tv_usec = 0;
                tvp = &tv;
            } else {
                /* Otherwise we can block */
                tvp = NULL; /* wait forever */
            }
        }

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

aeApiPoll會把觸發的事件放到觸發陣列（fired）中：

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;
        ......
        eventLoop->fired[j].fd = e->data.fd;
        eventLoop->fired[j].mask = mask;
    }
}

然後框架依次去執行觸發陣列的回撥函式：

for (j = 0; 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 = 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++;
}

最後會處理一下時間事件連結串列，其實就是檢查一下這個連結串列，如果有需要刪除的就觸發回收回撥並刪除，如果有時間到的那就觸發時間回撥：

    while(te) {
        long now_sec, now_ms;
        long long id;

        //這應該是上一輪標記需要刪除的時間事件，現在刪除並觸發回收回撥
        /* Remove events scheduled for deletion. */
        if (te->id == AE_DELETED_EVENT_ID) {
            aeTimeEvent *next = te->next;
            if (prev == NULL)
                eventLoop->timeEventHead = te->next;
            else
                prev->next = te->next;
            if (te->finalizerProc)
                te->finalizerProc(eventLoop, te->clientData);
            zfree(te);
            te = next;
            continue;
        }

        /* Make sure we don't process time events created by time events in
         * this iteration. Note that this check is currently useless: we always
         * add new timers on the head, however if we change the implementation
         * detail, this check may be useful again: we keep it here for future
         * defense. */
        if (te->id > maxId) {
            te = te->next;
            continue;
        }
        //如果事件已到，就觸發時間回撥，如果時間回撥返回AE_NOMORE，那就標記需要刪除這個時間事件。
        aeGetTime(&now_sec, &now_ms);
        //這裡還是有可能超過設定時間的，這種也需要觸發
        if (now_sec > te->when_sec ||
            (now_sec == te->when_sec && now_ms >= te->when_ms))
        {
            int retval;

            id = te->id;
            retval = te->timeProc(eventLoop, id, te->clientData);
            processed++;
            if (retval != AE_NOMORE) {
                aeAddMillisecondsToNow(retval,&te->when_sec,&te->when_ms);
            } else {
                te->id = AE_DELETED_EVENT_ID;
            }
        }
        prev = te;
        te = te->next;
    }

這種將時間事件作為poll的超時時間的機制可以很好的在一個事件迴圈中同時新增檔案時間和時間事件併兼容多種事件模型。
因為fd是以陣列的形式儲存的，所以一開始需要分配足夠的空間，而相應的觸發陣列和內部陣列也需要相應的大小。同時這種結構也無法向Windows相容。