Redis事件管理（二）

Redis的定时器是自己实现的，不是很复杂。说说具体的实现吧。

定时器的存储维护采用的是普通的单向链表结构，具体节点定义为：

 /*时间定时器结构体*/
 typedef struct aeTimeEvent
 {
     long long id; /*定时器的编号*/
     long when_sec; /* seconds */
     long when_ms; /* milliseconds */
     aeTimeProc *timeProc;/*时间到达处理函数*/
     aeEventFinalizerProc *finalizerProc;/*删除清理函数*/
     void *clientData;/*带外数据*/
     struct aeTimeEvent *next;/*定时器的存储采用的是链表结构*/
 } aeTimeEvent;

定时器记录的根节点的位置是在事件管理器中，剩下的就是普通的操作函数了

 /*添加定时器事件，参数为时间控制器，定时时间，处理函数，函数参数，清理函数*/
 long long aeCreateTimeEvent(aeEventLoop *eventLoop, long long milliseconds,
         aeTimeProc *proc, void *clientData,
         aeEventFinalizerProc *finalizerProc)
 {
     /*生成ID*/
     long long id = eventLoop->timeEventNextId++;
     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->next = eventLoop->timeEventHead;
     eventLoop->timeEventHead = te;
     return id;
 }

 /*删除时间节点，提供时间点的ID就好，如果没找到就返回错误*/
 int aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id)
 {
     aeTimeEvent *te, *prev = NULL;

     te = eventLoop->timeEventHead;
     /*循环查找节点，调用清理函数并释放内存*/
     while(te)
     {
         if (te->id == id)
         {
             if (prev == NULL)
                 eventLoop->timeEventHead = te->next;
             else
                 prev->next = te->next;
             if (te->finalizerProc)
                 te->finalizerProc(eventLoop, te->clientData);
             zfree(te);
             return AE_OK;
         }
         prev = te;
         te = te->next;
     }
     return AE_ERR; /* NO event with the specified ID found */
 }

 /*查找激活时间最短的节点*/
 static aeTimeEvent *aeSearchNearestTimer(aeEventLoop *eventLoop)
 {
     aeTimeEvent *te = eventLoop->timeEventHead;
     aeTimeEvent *nearest = NULL;

     while(te)
     {
         if (!nearest || te->when_sec < nearest->when_sec || (te->when_sec == nearest->when_sec && te->when_ms < nearest->when_ms))
             nearest = te;
         te = te->next;
     }
     return nearest;
 }

 /* Process time events 处理时间事件，先执行定时器事件，如果有时间设置过端的情况，会导致整个卡死*/
 static int processTimeEvents(aeEventLoop *eventLoop)
 {
     int processed = ;
     aeTimeEvent *te;
     long long maxId;
     time_t now = time(NULL);

     if (now < eventLoop->lastTime) /*为啥会出现当前时间小于上次激活时间的问题，重新设置了系统时间，当前时间小于了最后的插入时间*/
     {
         te = eventLoop->timeEventHead;
         while(te)
         {
             te->when_sec = ;
             te = te->next;
         }
     }
     eventLoop->lastTime = now;/*更新最后操作时间*/

     te = eventLoop->timeEventHead;
     maxId = eventLoop->timeEventNextId-;
     /*时间处理，从链表中逐个检查，找到到达时间的定时器后调用处理函数，然后重新从头遍历，当某个定时器的*/
     while(te)
     {
         long now_sec, now_ms;
         long long id;

         if (te->id > maxId)
         {
             te = te->next;
             continue;
         }
         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)
             {
                 /*返回值不为-1时需要重新注册函数，返回值为下次激活的时间*/
                 aeAddMillisecondsToNow(retval,&te->when_sec,&te->when_ms);
             }
             else
             {
                 /*删除定时器*/
                 aeDeleteTimeEvent(eventLoop, id);
             }
             /*定时器函数处理完毕之后为了防止漏掉节点，重新从头结点遍历，这个地方要注意，如果定时时间太短，这个地方会造成死循环，不停的处理定时器事件*/
             te = eventLoop->timeEventHead;
         }
         else
         {
             te = te->next;
         }
     }
     return processed;
 }