基于setitimer实现允许单进程多次调用的定时器

原理

setitimer不能在进程中多次调用，考虑用链表管理调用。每个节点包含当前事件还剩余多少时间，回调等，每次有新节点时，重新更新节点时间。在计数到来后，重新恢复节点初始时间实现重复计时，删除相对简单，挪掉节点即可。

函数原型

int set_timer(struct own_timer **t, struct timeval val, callback* cb, void* arg) ;int free_timer(struct own_timer* timer) ;

源码

#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <string.h>#include <signal.h>#include <errno.h>#include <sys/time.h>#include <pthread.h>#define MIN(a,b) (((a) < (b))?(a):(b))typedef void (*callback)(void* argc);typedef struct list {    void* next;    void* prev;} LIST_ENTRY;struct own_timer {    LIST_ENTRY entry;    int handle;    struct timeval left_dyn;    struct timeval left_init;    callback* cb;    void* cb_arg;};static LIST_ENTRY *head = NULL;static LIST_ENTRY *tail = NULL;static struct timeval last_set;static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;static int test = 0;static struct own_timer *t1 = NULL;static struct own_timer *t2 = NULL;static struct own_timer *t3 = NULL;void timeout(void* arg){    printf("timeout %d >>\n",(int)arg);}void timeout4(void* arg){    printf("timeout4 >>>>>>>>>\n");    test ++;}static int compare_time(struct timeval a, struct timeval b){    if(a.tv_sec > b.tv_sec)        return 1;    else if(a.tv_sec == b.tv_sec && a.tv_usec > b.tv_usec)         return 1;    else if(a.tv_sec == b.tv_sec && a.tv_usec == b.tv_usec)         return 0;    else        return -1;}static int diff_time(struct timeval* result, struct timeval* old,struct  timeval* newt){    if(compare_time(*old,*newt) < 0) {        //printf("old shoud bigger\n");        return -1;    }    if((old->tv_sec - newt->tv_sec) >= 1) {        old->tv_sec --;        old->tv_usec += 1000000;    }    result->tv_sec = old->tv_sec - newt->tv_sec;    result->tv_usec = old->tv_usec - newt->tv_usec;    if(result->tv_usec >= 1000000) {        result->tv_usec -= 1000000;        result->tv_sec ++;    }    return 0;}void sig_alarm(int sig){    if(sig == SIGALRM) {        LIST_ENTRY* tmp;        struct own_timer* ptr =NULL;        struct own_timer* ptr_min2nd = NULL;        struct timeval min;        struct timeval min_2nd;        callback* min_cb;        void* min_arg;        //printf("lock in sig_alarm\n");        pthread_mutex_lock(&mutex);        //printf("SIG_ALARM\n");        //遍历结点,找到left时间最小的, 可能有多个.一定是它发生了        if (head == NULL) {            //printf("free in sig_alarm\n");            pthread_mutex_unlock(&mutex);            //printf("no nodes in list\n");            return;         } else {            //printf("find min...\n");            tmp = head->next;            ptr = (struct own_timer*)tmp;            min = ptr->left_dyn;            do {                ptr = (struct own_timer*)tmp;                //printf("min(%d %d) cur(%d %d)\n",(int)min.tv_sec,(int)min.tv_usec,(int)ptr->left_dyn.tv_sec,(int)ptr->left_dyn.tv_usec);                if(compare_time(min,ptr->left_dyn) > 0) {                    min = ptr->left_dyn;                }                tmp = tmp->next;            }while(tmp != tail);            pthread_t tid;            tmp = head->next;            ptr = (struct own_timer*)tmp;            min_2nd = ptr->left_dyn;            ptr_min2nd = ptr;            //printf("excute min and find 2nd min ...\n");            do {                ptr = (struct own_timer*)tmp;                diff_time(&ptr->left_dyn,&ptr->left_dyn,&min);                //printf("left_dyn(%d %d)\n",(int)ptr->left_dyn.tv_sec,(int)ptr->left_dyn.tv_usec);                if (ptr->left_dyn.tv_usec == 0 && ptr->left_dyn.tv_sec == 0) {                    //printf("handle = %x\n",ptr->handle);                    //回调                    if(ptr->cb) {                        pthread_create(&tid,NULL,ptr->cb,ptr->cb_arg);                        //回调里可能链表已经释放了                    }                    //重新计时                    ptr->left_dyn = ptr->left_init;                    //printf("reset left_dyn(%d %d)\n",(int)ptr->left_dyn.tv_sec,(int)ptr->left_dyn.tv_usec);                }                //不等于0的节点中寻找最小的                if(ptr->left_dyn.tv_sec != 0 || ptr->left_dyn.tv_usec != 0) {                    if(compare_time(min_2nd,ptr->left_dyn) > 0) {                        min_2nd = ptr->left_dyn;                        ptr_min2nd = ptr;                    }                }                tmp = tmp->next;            }while(tmp != tail);        }        //开始min_2nd setitimer        //printf("min_2nd (%d %d)\n",(int)ptr_min2nd->left_dyn.tv_sec,(int)ptr_min2nd->left_dyn.tv_usec);        struct itimerval newt;        struct timeval interval;        interval.tv_sec = 0;        interval.tv_usec = 0;        newt.it_value = ptr_min2nd->left_dyn;        newt.it_interval = interval;        setitimer(ITIMER_REAL,&newt,NULL);        last_set = ptr_min2nd->left_dyn;    }    //printf("free in sig_alarm\n");    pthread_mutex_unlock(&mutex);}int free_timer(struct own_timer* timer) {    LIST_ENTRY* tmp;    LIST_ENTRY* tmp_prev;    LIST_ENTRY* tmp_next;    struct own_timer* ptr;    tmp = head->next;    ptr = (struct own_timer*)tmp;    //printf("lock in free_timer\n");    pthread_mutex_lock(&mutex);    do {        ptr = (struct own_timer*)tmp;        if (timer->handle == ptr->handle) {            //printf("found the node timer need free\n");            tmp_prev = tmp->prev;            tmp_next = tmp->next;            tmp_prev->next = tmp->next;            tmp_next->prev = tmp->prev;            break;        }        tmp = tmp->next;    } while(tmp != tail);#if 1    if(timer) free(timer);    if(head->next == tail) {        if(head) {            free(head);            head = NULL;        }        if(tail) {            free(tail);            tail = NULL;        }     }#endif    //printf("free in free_timer\n");    pthread_mutex_unlock(&mutex);    return 0;}int set_timer(struct own_timer **t, struct timeval val, callback* cb, void* arg) {    struct itimerval newt;    struct itimerval oldt;    struct timeval set,left,passed;    struct timeval interval;    LIST_ENTRY* tmp;    struct own_timer* ptr =NULL;    sigset_t news,olds;    //节点内存分配    (*t) = (struct own_timer*)malloc(sizeof(struct own_timer));    if(*t == NULL) {        perror("malloc fail");        return -1;    }       (*t)->left_dyn = (*t)->left_init = val;    (*t)->cb = cb;    (*t)->cb_arg = arg;    (*t)->handle = 0xFFFFFFFF & rand();    //printf("new handle = %x\n",*t->handle);    //屏蔽SIGALRM ，比较粗糙    sigemptyset(&news);    sigaddset(&news,SIGALRM);    sigprocmask(SIG_BLOCK,&news,&olds);    //锁    //printf("lock in set_timer\n");    pthread_mutex_lock(&mutex);    interval.tv_sec = 0;    interval.tv_usec =0;    newt.it_interval = interval;    //获得从上次setitimer到现在，计时器还剩多少时间.    getitimer(ITIMER_REAL,&oldt);    left = oldt.it_value;    //刚开始    if(left.tv_sec == 0 && left.tv_usec == 0 && head == NULL) {        //printf("setitimer 1st start\n");        newt.it_value = val ;        setitimer(ITIMER_REAL,&newt,NULL);        last_set = val;        head = (LIST_ENTRY*)malloc(sizeof(LIST_ENTRY));        tail = (LIST_ENTRY*)malloc(sizeof(LIST_ENTRY));        //插入第１个节点        head->next = &((*t)->entry);        (*t)->entry.prev = head;        (*t)->entry.next = tail;        tail->prev = *t;        head->prev = tail;        tail->next = head;    } else if(left.tv_sec == 0 && left.tv_usec == 0 && head != NULL) {         //printf("setitimer timer stop\n");        newt.it_value = val ;        setitimer(ITIMER_REAL,&newt,NULL);        last_set = val;        tmp = head->next;        do {            tmp = tmp->next;        }while(tmp != tail);        //顺序插入节点        tmp = tmp->prev;        tmp->next = &((*t)->entry);        (*t)->entry.prev = tmp;        (*t)->entry.next = tail;        tail->prev = *t;    } else {        //printf("setitimer timer running\n");        //换算成消耗的时间. last_set是在setitimer后保存的timeval        diff_time(&passed,&last_set,&left);         //printf("passed time(%d %d)\n",(int)passed.tv_sec,(int)passed.tv_usec);        //剩余时间比当前想设置的计时大，重设置计时为当前计时。        if(compare_time(left,val) >= 0 ) {            newt.it_value = val ;            setitimer(ITIMER_REAL,&newt,NULL);        }         //每个结点需要减已消耗的时间。        tmp = head->next;        do {            ptr = (struct own_timer*)tmp;            //printf("handle %x:\n",ptr->handle);            //printf("before diff left_dyn(%d %d)\n",(int)ptr->left_dyn.tv_sec,(int)ptr->left_dyn.tv_usec);            diff_time(&ptr->left_dyn,&ptr->left_dyn,&passed);            //printf("after diff left_dyn(%d %d)\n",(int)ptr->left_dyn.tv_sec,(int)ptr->left_dyn.tv_usec);            tmp = tmp->next;        }while(tmp != tail);        //尾部插入节点        tmp = tmp->prev;        tmp->next = &((*t)->entry);        (*t)->entry.prev = tmp;        (*t)->entry.next = tail;        tail->prev = *t;    }    //恢复    sigprocmask(SIG_SETMASK,&olds,NULL);    //解锁    //printf("free in set_timer\n");    pthread_mutex_unlock(&mutex);    //printf("recover SIGALRM\n");    return 0;}void* thread_set_timer(void* arg){    struct own_timer *timer;    struct timeval val;    val.tv_sec = 0;    val.tv_usec = 500000;    set_timer(&timer, val, timeout4, NULL); }int main (int argc, char* argv[]){    struct timeval val;    signal(SIGALRM,sig_alarm);    int i = 0;    for (i = 1;i <= 500; i++) {        val.tv_sec = i;        val.tv_usec = 0;        set_timer(&t1, val, timeout, i);     }    //pthread_t tid;    //pthread_create(&tid,NULL,thread_set_timer,NULL);    while(1) {#if 0        printf("test = %d\n",test);        if(test == 10) {            free_timer(t2);            free_timer(t3);        }        if(test == 15) {            free_timer(t1);            set_timer(&t2, val, timeout2, NULL);             set_timer(&t3, val, timeout3, NULL);         }#endif        sleep(1);    }    return 0;}

运行结果

timeout 1 >>
timeout 2 >>
timeout 3 >>
timeout 1 >>
timeout 4 >>
timeout 1 >>
timeout 2 >>
timeout 5 >>

后续考虑优化

1 不使用信号

setitimer利用SIGALARM信号，期间不能使用sleep()等系统调用，用相同功能的函数代替之，比如用sleep+thread实现一个setitimer，自己实现回调。
要求严格计时，在主线程里的主回调相当与sig_alarm.这个线程的优先级应该最高保证每次计时完成时，都能及时调用主回调。

2 数据结构

双向链表在大量定时器申请时，并无优势，可换成最小堆。

3 原理改进

考虑时间轮　并且tick分级。比如　某次定时需要5555个tick 每轮１000 需要 5*1000 +5*100 + 5*10 +5个tick。在不同时间轮上，计数不同片，最后等待轮最大的完成即可。