时间驱动：探索计时器方案和革命性的时间轮技术

// ... 其他代码
while(!quit)
{
   
    int timeout=get_nearest_timer()-now_time();
    if(timeout<0)
        timeout=-1;
    int event_count=epoll_wait(epfd,ev,ev_num,timeout);
    for(int i=0;i<event_count;i++)
    {
   
        // ... 处理网络事件
    }
    // 处理定时事件
    update_timer();// 里面检测是否到时间处理定时任务，如果没有到时间直接返回
    // ... 其他代码
}
// ... 其他代码

// server.c
int main(int argc,char *argv[])
{
   
    // ... 其他代码

    aeMain(server.el);//事件循环

    // ... 其他代码
}
// ... 其他代码

// ae.c
// ... 其他代码

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

// ... 其他代码

int aeProcessEvents(aeEventLoop *eventLoop, int flags)
{
   
    // ... 其他代码
    if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT))
            usUntilTimer = usUntilEarliestTimer(eventLoop);//获取最近定时器任务

            if (usUntilTimer >= 0) {
   
                tv.tv_sec = usUntilTimer / 1000000;
                tv.tv_usec = usUntilTimer % 1000000;
                tvp = &tv;
            } 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 = 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;
            }

            if (eventLoop->beforesleep != NULL && flags & AE_CALL_BEFORE_SLEEP)
                eventLoop->beforesleep(eventLoop);

            /* Call the multiplexing API, will return only on timeout or when
             * some event fires. */
            numevents = aeApiPoll(eventLoop, tvp);// 进入epoll_wait()，处理IO事件

            // ... 其他代码
    }
    // ... 其他代码

    /* Check time events */
    if (flags & AE_TIME_EVENTS)
        processed += processTimeEvents(eventLoop);//处理定时器事件

    return processed; /* return the number of processed file/time events */
}
// ... 其他代码

// ae_epoll.c

// ... 其他代码

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 + 999)/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;
            eventLoop->fired[j].fd = e->data.fd;
            eventLoop->fired[j].mask = mask;
        }
    } else if (retval == -1 && errno != EINTR) {
   
        panic("aeApiPoll: epoll_wait, %s", strerror(errno));
    }

    return numevents;
}

// ... 其他代码

// 网络事件和定时事件在不同线程中处理
void * thread_timer(void *thread_param) {
   
    init_timer();
    while (!quit) {
   
        update_timer();
        usleep(t);
   }
    clear_timer();
    return NULL; 
}
pthread_create(&pid,NULL,thread_timer,&params);

// 初始化定时器
void init_timer();

// 添加定时器
Node *add_timer(int expire,callback cb);

// 删除定时器
bool delete_timer(Node* node);

// 找到最近要触发的定时任务
Node* find_nearest_timer();

// 更新检测定时器
void update_timer();

// 清除定时器
void clear_timer();

struct timer_event {
   
    uint32_t handle;
    int session;
};

// 定时任务
struct timer_node {
   
    struct timer_node *next;
    uint32_t expire;
};
// 任务链表
struct link_list {
   
    struct timer_node head;
    struct timer_node *tail;
};

struct timer {
   
    struct link_list near[TIME_NEAR];
    struct link_list t[4][TIME_LEVEL];
    struct spinlock lock;    // 自旋锁，多线程操作需要，时间复杂度O(1)
    uint32_t time;            //时间指针，范围是2^32*10ms
    uint32_t starttime;
    uint64_t current;
    uint64_t current_point;
};

static uint64_t
gettime() {
   
    uint64_t t;
    struct timespec ti;
    clock_gettime(CLOCK_MONOTONIC, &ti);
    t = (uint64_t)ti.tv_sec * 100;
    t += ti.tv_nsec / 10000000;
    return t;
}

lock(&mutex)
//执行临界资源
unlock(&mutex)