《Linux高性能服务器编程》学习总结（十一）——定时器

第十一章 定时器

　　这里的定时器主要指的是定时器容器，TCP连接中有保活定时器，为了定期查看TCP连接是否断开，可以用socket选项实现，但是较为麻烦，所以一般都由应用层负责保活，这是定时器的一个运用场景，或者在应用层需要执行一些定时操作，这样就需要一个高效的定时器容器，主要是时间轮和时间堆，当然定时器也可以用SIGALRM信号以及I/O复用实现。

　　socket选项中我们使用SO_RCVTIMEO和SO_SNDTIMEO两个选项进行设置，我们来看一个例子：

/*************************************************************************
    > File Name: 11-1.cpp
    > Author: Torrance_ZHANG
    > Mail: 597156711@qq.com
    > Created Time: Sat 10 Feb 2018 11:13:03 PM PST
 ************************************************************************/

#include"head.h"
using namespace std;

int timeout_connect(const char* ip, int port, int time) {
    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    assert(sockfd >= 0);

    struct timeval timeout;
    timeout.tv_sec = time;
    timeout.tv_usec = 0;
    socklen_t len = sizeof(timeout);
    ret = setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, len);
    assert(ret != -1);

    ret = connect(sockfd, (struct sockaddr*)&address, sizeof(address));
    if(ret == -1) {
        if(errno == EINPROGRESS) {
            printf("connection timeout, process timeout logic 
");
            return -1;
        }
        printf("error occur when connection to server
");
        return -1;
    }
    return sockfd;
}

int main(int argc, char** argv) {
    if(argc <= 2) {
        printf("usage: %s ip_address port_number
", basename(argv[0]));
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi(argv[2]);

    int sockfd = timeout_connect(ip, port, 10);
    if(sockfd < 0) return 1;
    else return 0;
}

　　我们用5-7的服务器，将监听队列改成1，用两个telnet客户端占用监听队列，这样再运行这个客户端后，等待10s出现超时的结果。

　　关于SIGALRM信号，我们知道他是当定时器到时时系统给应用程序的通知，所以基于这个信号，我们设计一个基于升序链表的定时器结构，为了引用方便，我们写在头文件中，其按照超时时间升序排序：

/*************************************************************************
    > File Name: lst_timer.h
    > Author: Torrance_ZHANG
    > Mail: 597156711@qq.com
    > Created Time: Sat 10 Feb 2018 11:39:56 PM PST
 ************************************************************************/

#ifndef _LST_TIMER_H
#define _LST_TIMER_H

#include<time.h>
#define BUFFER_SIZE 64
class util_timer;

struct client_data {
    sockaddr_in address;
    int sockfd;
    char buf[BUFFER_SIZE];
    util_timer* timer;
};

class util_timer {
public:
    util_timer() : prev(NULL), next(NULL) {}
public:
    time_t expire;
    void (*cb_func)(client_data*);
    client_data* user_data;
    util_timer* prev;
    util_timer* next;
};

class sort_timer_lst {
public:
    sort_timer_lst() : head(NULL), tail(NULL) {}
    ~sort_timer_lst() {
        util_timer* tmp = head;
        while(tmp) {
            head = tmp -> next;
            delete tmp;
            tmp = head;
        }
    }
    void add_timer(util_timer* timer) {
        if(!timer) return;
        if(!head) {
            head = tail = timer;
            return;
        }
        if(timer -> expire < head -> expire) {
            timer -> next = head;
            head -> prev = timer;
            head = timer;
            return;
        }
        add_timer(timer, head);
    }
    void adjust_timer(util_timer* timer) {
        if(!timer) return;
        util_timer* tmp = timer -> next;
        if(!tmp || (timer -> expire < tmp -> expire)) return;
        if(timer == head) {
            head = head -> next;
            head -> prev = NULL;
            timer -> next = NULL;
            add_timer(timer, head);
        }
        else {
            timer -> prev -> next = timer -> next;
            timer -> next -> prev = timer -> prev;
            add_timer(timer, timer -> next);
        }
    }
    void del_timer(util_timer* timer) {
        if(!timer) return;
        if((timer == head) && (timer == tail)) {
            delete timer;
            head = NULL;
            tail = NULL;
            return;
        }
        if(timer == head) {
            head = head -> next;
            head -> prev = NULL;
            delete timer;
            return;
        }
        if(timer == tail) {
            tail = tail -> prev;
            tail -> next = NULL;
            delete timer;
            return;
        }
        timer -> prev -> next = timer -> next;
        timer -> next -> prev = timer -> prev;
        delete timer;
    }
    void tick() {
        if(!head) return;
        printf("timer tick
");
        time_t cur = time(NULL);
        util_timer* tmp = head;
        while(tmp) {
            if(cur < tmp -> expire) break;
            tmp -> cb_func(tmp -> user_data);
            head = tmp -> next;
            if(head) head -> prev = NULL;
            delete tmp;
            tmp = head;
        }
    }
private:
    void add_timer(util_timer* timer, util_timer* lst_head) {
        util_timer* prev = lst_head;
        util_timer* tmp = prev -> next;
        while(tmp) {
            if(timer -> expire < tmp -> expire) {
                prev -> next = timer;
                timer -> next = tmp;
                tmp -> prev = timer;
                timer -> prev = prev;
                break;
            }
            prev = tmp;
            tmp = tmp -> next;
        }
        if(!tmp) {
            prev -> next = timer;
            timer -> prev = prev;
            timer -> next = NULL;
            tail = timer;
        }
    }
private:
    util_timer* head;
    util_timer* tail;
};

#endif

　　接下来我们看一下其实际应用——处理非活动的连接，在服务器运行时，对于很多已经建立的TCP连接并不是时时刻刻都有数据发送，所以我们对于每个TCP连接都要有一个定时器，一旦其没有数据的状态持续一定的时间就可以认为这是非活动的连接并且将之关闭，目的是节省服务器的资源：

/*************************************************************************
    > File Name: 11-3.cpp
    > Author: Torrance_ZHANG
    > Mail: 597156711@qq.com
    > Created Time: Sun 11 Feb 2018 04:23:50 AM PST
 ************************************************************************/

#include"head.h"
#include"lst_timer.h"
using namespace std;

#define FD_LIMIT 65535
#define MAX_EVENT_NUMBER 1024
#define TIMESLOT 5

static int pipefd[2];
static sort_timer_lst timer_lst;
static int epollfd = 0;

int setnonblocking(int fd) {
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

void addfd(int epollfd, int fd) {
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

void sig_handler(int sig) {
    int save_errno = errno;
    int msg = sig;
    send(pipefd[1], (char*)&msg, 1, 0);
    errno = save_errno;
}

void addsig(int sig) {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = sig_handler;
    sa.sa_flags |= SA_RESTART;
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

void timer_handler() {
    timer_lst.tick();
    alarm(TIMESLOT);
}

void cb_func(client_data* user_data) {
    epoll_ctl(epollfd, EPOLL_CTL_DEL, user_data -> sockfd, 0);
    assert(user_data);
    close(user_data -> sockfd);
    printf("close fd %d
", user_data -> sockfd);
}

int main(int argc, char** argv) {
    if(argc <= 2) {
        printf("usage: %s ip_address port_number
", basename(argv[0]));
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    assert(listenfd >= 0);

    ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
    if(ret == -1) {
        printf("errno is %d
", errno);
        return 1;
    }
    ret = listen(listenfd, 5);
    assert(ret != -1);

    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);
    addfd(epollfd, listenfd);

    ret = socketpair(PF_UNIX, SOCK_STREAM, 0, pipefd);
    assert(ret != -1);
    setnonblocking(pipefd[1]);
    addfd(epollfd, pipefd[0]);
    
    addsig(SIGALRM);
    addsig(SIGTERM);
    bool stop_server = false;
    client_data* users = new client_data[FD_LIMIT];
    bool timeout = false;
    alarm(TIMESLOT);

    while(!stop_server) {
        int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if((number < 0) && (errno != EINTR)) {
            printf("epoll failure
");
            break;
        }
        for(int i = 0; i < number; i ++) {
            int sockfd = events[i].data.fd;
            if(sockfd == listenfd) {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof(address);
                int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
                addfd(epollfd, connfd);
                users[connfd].address = client_address;
                users[connfd].sockfd = connfd;

                util_timer* timer = new util_timer;
                timer -> user_data = &users[connfd];
                timer -> cb_func = cb_func;
                time_t cur = time(NULL);
                timer -> expire = cur + 3 * TIMESLOT;
                users[connfd].timer = timer;
                timer_lst.add_timer(timer);
            }
            else if((sockfd == pipefd[0]) && (events[i].events & EPOLLIN)) {
                int sig;
                char signals[1024];
                ret = recv(pipefd[0], signals, sizeof(signals), 0);
                if(ret == -1) continue;
                else if(ret == 0) continue;
                else {
                    for(int i = 0; i < ret; i ++) {
                        switch(signals[i]) {
                            case SIGALRM: {
                                timeout = true;
                                break;
                            }
                            case SIGTERM: {
                                stop_server = true;
                            }
                        }
                    }
                }
            }
            else if(events[i].events & EPOLLIN) {
                memset(users[sockfd].buf, 0, BUFFER_SIZE);
                ret = recv(sockfd, users[sockfd].buf, BUFFER_SIZE, 0);
                printf("get %d bytes of client data %s from %d
", ret, users[sockfd].buf, sockfd);

                util_timer* timer = users[sockfd].timer;
                if(ret < 0) {
                    if(errno != EAGAIN) {
                        cb_func(&users[sockfd]);
                        if(timer) {
                            timer_lst.del_timer(timer);
                        }
                    }
                }
                else if(ret == 0) {
                    cb_func(&users[sockfd]);
                    if(timer) {
                        timer_lst.del_timer(timer);
                    }
                }
                else {
                    if(timer) {
                        time_t cur = time(NULL);
                        timer -> expire = cur + 3 * TIMESLOT;
                        printf("adjust timer once
");
                        timer_lst.adjust_timer(timer);
                    }
                }
            }
            else {}
        }
        if(timeout) {
            timer_handler();
            timeout = false;
        }
    }
    close(listenfd);
    close(pipefd[1]);
    close(pipefd[0]);
    delete [] users;
    return 0;
}

　　我们可以看到，客户端连接一段时间后没有数据发送，服务器端就自动关闭连接，以节省服务器资源。

　　前面提到I/O复用系统调用的最后一个timeval参数时说过这个是用来控制超时时间的，所以我们也可以用这个参数作为定时，但是我们需要不断更新这个定时参数，用一个代码来说明一下：

/*************************************************************************
    > File Name: 11-4.cpp
    > Author: Torrance_ZHANG
    > Mail: 597156711@qq.com
    > Created Time: Mon 12 Feb 2018 01:49:52 AM PST
 ************************************************************************/

#include<iostream>
using namespace std;

#define TIMEOUT 5000

int main() {
    time_t start = time(NULL);
    time_t end = time(NULL);
    int timeout = TIMEOUT;

    while(1) {
        printf("the timeout is now %d mil-seconds
", timeout);
        start = time(NULL);
        int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, timeout);
        if((number < ) && (errno != EINTR)) {
            printf("epoll failure
");
            break;
        }
        if(number == 0) {
            timeout = TIMEOUT;
            continue;
        }
        end = time(NULL);
        timeout -= (end - start) * 1000;
        if(timeout <= 0) timeout = TIMEOUT;
    }
}

　　前面我们提到的基于升序链表的定时器容器存在着一个问题，就是添加和删除定时器的效率偏低，当定时器很多的时候，每次添加都要从头开始遍历寻找应该插入的位置，所以我们用了一种新的定时器容器——时间轮就很好地解决了这个问题。

　　什么是时间轮，这个名字很形象，时间轮就像是一个轮子，我们虚拟一个指针指向轮子上的每一个槽，这个指针每隔一个时间间隔就走到下一个槽，这个时间间隔就是心搏时间，也是时间轮的槽时间si，而每一个槽其实就是一个指向一条定时器链表的头指针，每条链表上的定时器的定时时间相差N*si的整数倍，这个思想和哈希的思想很像。

/*************************************************************************
    > File Name: time_wheel_timer.h
    > Author: Torrance_ZHANG
    > Mail: 597156711@qq.com
    > Created Time: Mon 12 Feb 2018 05:13:13 AM PST
 ************************************************************************/

#ifndef _TIME_WHEEL_TIMER_H
#define _TIME_WHEEL_TIMER_H

#include<time.h>
#include<netinet/in.h>
#include<stdio.h>

#define BUFFER_SIZE 64
class tw_timer;

struct client_data {
    sockaddr_in address;
    int sockfd;
    char buf[BUFFER_SIZE];
    tw_timer* timer;
};

class tw_timer {
public:
    tw_timer(int rot, int ts) : next(NULL), prev(NULL), rotation(rot), time_slot(ts) {}
public:
    int rotation;
    int time_slot;
    void (*cb_func)(client_data*);
    client_data* user_data;
    tw_timer* next;
    tw_timer* prev;
};

class time_wheel {
public:
    time_wheel() : cur_slot(0) {
        for(int i = 0; i < N; ++ i) {
            slots[i] = NULL;
        }
    }
    ~time_wheel() {
        for(int i = 0; i < N; i ++) {
            tw_timer* tmp = slots[i];
            while(tmp) {
                slots[i] = tmp -> next;
                delete tmp;
                tmp = slots[i];
            }
        }
    }
    tw_timer* add_timer(int timeout) {
        if(timeout < 0) return NULL;
        int ticks = 0;
        if(timeout < SI) {
            ticks = 1;
        }
        else ticks = timeout / SI;
        int rotation = ticks / N;
        int ts = (cur_slot + (ticks % N)) % N;
        tw_timer* timer = new tw_timer(rotation, ts);
        if(!slots[ts]) {
            printf("add timer, rotation is %d, ts is %d, cur_slot is %d
", rotation, ts, cur_slot);
            slots[ts] = timer;
        }
        else {
            timer -> next = slots[ts];
            slots[ts] -> prev = timer;
            slots[ts] = timer;
        }
        return timer;
    }
    void del_timer(tw_timer* timer) {
        if(!timer) return;
        int ts = timer -> time_slot;
        if(timer == slots[ts]) {
            slots[ts] = slots[ts] -> next;
            if(slots[ts]) {
                slots[ts] -> prev = NULL;
            }
            delete timer;
        }
        else {
            timer -> prev -> next = timer -> next;
            if(timer -> next) {
                timer -> next -> prev = timer -> prev;
            }
            delete timer;
        }
    }
    void tick() {
        tw_timer* tmp = slots[cur_slot];
        printf("current slot is %d
", cur_slot);
        while(tmp) {
            printf("tick the timer once
");
            if(tmp -> rotation > 0) {
                tmp -> rotation --;
                tmp = tmp -> next;
            }
            else {
                tmp -> cb_func(tmp -> user_data);
                if(tmp == slots[cur_slot]) {
                    printf("delete header in cur_slot
");
                    slots[cur_slot] = tmp -> next;
                    delete tmp;
                    if(slots[cur_slot]) {
                        slots[cur_slot] -> prev = NULL;
                    }
                    tmp = slots[cur_slot];
                }
                else {
                    tmp -> prev -> next = tmp -> next;
                    if(tmp -> next) {
                        tmp -> next -> prev = tmp -> prev;
                    }
                    tw_timer* tmp2 = tmp -> next;
                    delete tmp;
                    tmp = tmp2;
                }
            }
        }
        cur_slot = ++cur_slot % N;
    }
private:
    static const int N = 60;
    static const int SI = 1;
    tw_timer* slots[N];
    int cur_slot;
};

#endif

　　我们来将11-3的程序修改一下，使用时间轮来进行定时：

/*************************************************************************
    > File Name: 11-3.cpp
    > Author: Torrance_ZHANG
    > Mail: 597156711@qq.com
    > Created Time: Sun 11 Feb 2018 04:23:50 AM PST
 ************************************************************************/

#include"head.h"
#include"time_wheel_timer.h"
using namespace std;

#define FD_LIMIT 65535
#define MAX_EVENT_NUMBER 1024
#define TIMESLOT 1

static int pipefd[2];
static time_wheel t_wheel;
static int epollfd = 0;

int setnonblocking(int fd) {
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

void addfd(int epollfd, int fd) {
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

void sig_handler(int sig) {
    int save_errno = errno;
    int msg = sig;
    send(pipefd[1], (char*)&msg, 1, 0);
    errno = save_errno;
}

void addsig(int sig) {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = sig_handler;
    sa.sa_flags |= SA_RESTART;
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

void timer_handler() {
    t_wheel.tick();
    alarm(TIMESLOT);
}

void cb_func(client_data* user_data) {
    epoll_ctl(epollfd, EPOLL_CTL_DEL, user_data -> sockfd, 0);
    assert(user_data);
    close(user_data -> sockfd);
    printf("close fd %d
", user_data -> sockfd);
}

int main(int argc, char** argv) {
    if(argc <= 2) {
        printf("usage: %s ip_address port_number
", basename(argv[0]));
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    assert(listenfd >= 0);

    ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
    if(ret == -1) {
        printf("errno is %d
", errno);
        return 1;
    }
    ret = listen(listenfd, 5);
    assert(ret != -1);

    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);
    addfd(epollfd, listenfd);

    ret = socketpair(PF_UNIX, SOCK_STREAM, 0, pipefd);
    assert(ret != -1);
    setnonblocking(pipefd[1]);
    addfd(epollfd, pipefd[0]);
    
    addsig(SIGALRM);
    addsig(SIGTERM);
    bool stop_server = false;
    client_data* users = new client_data[FD_LIMIT];
    bool timeout = false;
    alarm(TIMESLOT);

    while(!stop_server) {
        int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if((number < 0) && (errno != EINTR)) {
            printf("epoll failure
");
            break;
        }
        for(int i = 0; i < number; i ++) {
            int sockfd = events[i].data.fd;
            if(sockfd == listenfd) {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof(address);
                int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
                addfd(epollfd, connfd);
                users[connfd].address = client_address;
                users[connfd].sockfd = connfd;

                tw_timer* new_timer = t_wheel.add_timer(15 * TIMESLOT);
                new_timer -> user_data = &users[connfd];
                new_timer -> cb_func = cb_func;
                users[connfd].timer = new_timer;
            }
            else if((sockfd == pipefd[0]) && (events[i].events & EPOLLIN)) {
                int sig;
                char signals[1024];
                ret = recv(pipefd[0], signals, sizeof(signals), 0);
                if(ret == -1) continue;
                else if(ret == 0) continue;
                else {
                    for(int i = 0; i < ret; i ++) {
                        switch(signals[i]) {
                            case SIGALRM: {
                                timeout = true;
                                break;
                            }
                            case SIGTERM: {
                                stop_server = true;
                            }
                        }
                    }
                }
            }
            else if(events[i].events & EPOLLIN) {
                memset(users[sockfd].buf, 0, BUFFER_SIZE);
                ret = recv(sockfd, users[sockfd].buf, BUFFER_SIZE, 0);
                printf("get %d bytes of client data %s from %d
", ret, users[sockfd].buf, sockfd);

                tw_timer* timer = users[sockfd].timer;
                if(ret < 0) {
                    if(errno != EAGAIN) {
                        cb_func(&users[sockfd]);
                        if(timer) {
                            t_wheel.del_timer(timer);
                        }
                    }
                }
                else if(ret == 0) {
                    cb_func(&users[sockfd]);
                    if(timer) {
                        t_wheel.del_timer(timer);
                    }
                }
                else {
                    if(timer) {
                        t_wheel.del_timer(timer);
                        tw_timer* new_timer = t_wheel.add_timer(15 * TIMESLOT);
                        new_timer -> user_data = &users[sockfd];
                        new_timer -> cb_func = cb_func;
                        users[sockfd].timer = new_timer;
                    }
                }
            }
            else {}
        }
        if(timeout) {
            timer_handler();
            timeout = false;
        }
    }
    close(listenfd);
    close(pipefd[1]);
    close(pipefd[0]);
    delete [] users;
    return 0;
}

　　时间轮每秒转动一格，当15s没有消息发送的时候就会自动断开连接。对于时间轮而言，添加和删除一个定时器的时间复杂度是O(1)，执行一个定时器的时间复杂度表面上看是O(n)，但是由于我们将所有定时器散列到不同的链表中，所以每条链表上的定时器其实很少，当时用多个时间轮的时候其复杂度可以降至接近O(1)，所以其效率是很高的。

　　对于时间堆，有数据结构基础的话其实很好理解，就是一个基于时间排序的小根堆，每一次添加操作可以用O(lgn)的复杂度完成，而执行和删除堆顶的操作复杂度为O(1)，只是删除后需要将堆进行调整，其复杂度也约为O(lgn)。整体来看时间堆的复杂度也是很好的，我们来看一下代码：

/*************************************************************************
    > File Name: min_heap.h
    > Author: Torrance_ZHANG
    > Mail: 597156711@qq.com
    > Created Time: Mon 12 Feb 2018 09:31:19 PM PST
 ************************************************************************/

#ifndef _MIN_HEAP_H
#define _MIN_HEAP_H

#include<iostream>
#include<netinet/in.h>
#include<time.h>

using std::exception;

#define BUFFER_SIZE 64
class heap_timer;

struct client_data {
    sockaddr_in address;
    int sockfd;
    char buf[BUFFER_SIZE];
    heap_timer* timer;
};

class heap_timer {
public:
    heap_timer(int delay) {
        expire = time(NULL) + delay;
    }
public:
    time_t expire;
    void (*cb_func)(client_data*);
    client_data* user_data;
};

class time_heap {
public:
    time_heap(int cap) throw (std::exception) : capacity(cap), cur_size(0) {
        array = new heap_timer* [capacity];
        if(!array) throw std::exception();
        for(int i = 0; i < capacity; i ++) {
            array[i] = NULL;
        }
    }
    time_heap(heap_timer** init_array, int size, int capacity) throw (std::exception) : cur_size(size), capacity(capacity) {
        if(capacity < size) throw std::exception();
        array = new heap_timer* [capacity];
        if(!array) throw std::exception();
        for(int i = 0; i < capacity; i ++) {
            array[i] = NULL;
        }
        if(size != 0) {
            for(int i = 0; i < size; i ++) {
                array[i] = init_array[i];
            }
            for(int i = (cur_size - 1) / 2; i >= 0; -- i) {
                percolate_down(i);
            }
        }
    }
    ~time_heap() {
        for(int i = 0; i < cur_size; i ++) {
            delete array[i];
        }
        delete [] array;
    }
public:
    void add_timer(heap_timer* timer) throw (std::exception) {
        if(!timer) return;
        if(cur_size >= capacity) resize();
        int hole = cur_size ++;
        int parent = 0;
        for(; hole > 0; hole = parent) {
            parent = (hole - 1) / 2;
            if(array[parent] -> expire <= timer -> expire) break;
            array[hole] = array[parent];
        }
        array[hole] = timer;
    }
    void del_timer(heap_timer* timer) {
        if(!timer) return;
        //延迟销毁，这样可以节省删除定时器的开销，但是会使堆数组膨胀，空间换时间
        timer -> cb_func = NULL;
    }
    heap_timer* top() const {
        if(empty()) return NULL;
        return array[0];
    }
    void pop_timer() {
        if(empty()) return;
        if(array[0]) {
            delete array[0];
            array[0] = array[-- cur_size];
            percolate_down(0);
        }
    }
    void tick() {
        heap_timer* tmp = array[0];
        time_t cur = time(NULL);
        while(!empty()) {
            if(!tmp) break;
            if(tmp -> expire > cur) break;
            if(array[0] -> cb_func) array[0] -> cb_func(array[0] -> user_data);
            pop_timer();
            tmp = array[0];
        }
    }
    bool empty() const {
        return cur_size == 0;
    }
private:
    void percolate_down(int hole) {
        heap_timer* temp = array[hole];
        int child = 0;
        for(; ((hole * 2 + 1) <= (cur_size - 1)); hole = child) {
            child = hole * 2 + 1;
            if((child < (cur_size - 1)) && (array[child + 1] -> expire < array[child] -> expire)) ++child;
            if(array[child] -> expire < temp -> expire) array[hole] = array[child];
            else break;
        }
        array[hole] = temp;
    }
    void resize() throw (std::exception) {
        heap_timer** temp = new heap_timer* [2 * capacity];
        for(int i = 0; i < 2 * capacity; i ++) {
            temp[i] = NULL;
        }
        if(!temp) {
            throw std::exception();
        }
        capacity = 2 * capacity;
        for(int i = 0; i < cur_size; i ++) {
            temp[i] = array[i];
        }
        delete [] array;
        array = temp;
    }
private:
    heap_timer** array;
    int capacity;
    int cur_size;
};

#endif