本文摘自    https://www.cnblogs.com/embedded-linux/p/9093990.html

应用层使用timer可以启动多个timer(每个timer管理一个目标时间)，也可启用一个timer来管理多个目标时间。

多个timer时每个timer占用一部分空间，且存在多个timer同时到期的先后顺序问题(未多考虑，是否有问题待确定)，可采用单个timer管理程序所有定时事件，即如何实现序列化的timer。

涉及到链表(记录多个目标时间的到期时间)，信号处理函数(在SIG_ALAM函数中处理timer事件，并启动下一个timer时间点)。

#include

#include

#include

#include

#include

#include

#include

#include "list.h"

#define TIMERID_FIRST 100

typedef void (*stimer_func)(void *arg);

struct signal_timer{

struct list_head list_timer;

int id;

struct timeval itv;

struct timeval atv;

stimer_func stimer_handler;

void *arg;

};

int g_id;

struct list_head g_signal_list;

void alarm_handler(int sig);

int timer_init(void);

void timer_destroy(void);

// Return: id >0, in case of success; -1 in case of error.

int timer_add(long sec, long usec, void (*stimer_func)(void *arg), void *arg);

void timer_del(int id, int is_free);

static long long diff_time(struct timeval *t1, struct timeval *t2)

{

long long t1_usec = (t1->tv_sec * 1000 * 1000 + t1->tv_usec);

long long t2_usec = (t2->tv_sec * 1000 * 1000 + t2->tv_usec);

return (t1_usec - t2_usec);

}

static int max_time(struct timeval *t1, struct timeval *t2)

{

if(t1->tv_sec < t2->tv_sec){

return -1;

} else if(t1->tv_sec > t2->tv_sec){

return 1;

} else {

if(t1->tv_usec < t2->tv_usec){

return -1;

} else if(t1->tv_usec > t2->tv_usec){

return 1;

} else {

return 0;

}

}

}

#define min_time(t1, t2) (((t1).tv_sec < (t2).tv_sec) || \

(((t1).tv_sec == (t2).tv_sec) && \

((t1).tv_usec < (t2).tv_usec)))

#define MAX_USEC 999999

#define TV_MINUS(t1, t2, target) if((t1).tv_usec >= (t2).tv_usec){ \

(target).tv_sec = (t1).tv_sec - (t2).tv_sec;\

(target).tv_usec = (t1).tv_usec - (t2).tv_usec;\

} else { \

(target).tv_sec = (t1).tv_sec - (t2).tv_sec - 1;\

(target).tv_usec = (t1).tv_usec + (MAX_USEC - (t2).tv_usec);\

}

void alarm_handler(int sig)

{

struct timespec ts;

struct timeval tv;

struct timeval tv_min, *ptv_min;

struct itimerval it;

struct signal_timer *pstimer = NULL, *next= NULL;

int ret = 0;

if(list_empty(&g_signal_list))

return ;

// pstimer = list_first_entry(&g_signal_list, struct signal_timer, list_timer);

// ptv_min = &(pstimer->atv);

ptv_min = &tv_min;

clock_gettime(CLOCK_MONOTONIC_RAW, &ts);

tv.tv_sec = ts.tv_sec;

tv.tv_usec = ts.tv_nsec / 1000;

// printf("now time: %ld:%ld\n", tv.tv_sec, tv.tv_usec);

tv_min = tv;

tv_min.tv_sec += 1000; //default 1000s once

// two methods: sequence the timer list in case of more timers,

// not sequence in case of fewer timers.

list_for_each_entry_safe(pstimer, next, &g_signal_list, list_timer){

// printf("timerid:%d, aim time: %ld:%ld\n", pstimer->id, pstimer->atv.tv_sec, pstimer->atv.tv_usec);

if(max_time(&pstimer->atv, &tv) <= 0){

if(pstimer->stimer_handler != NULL){

pstimer->stimer_handler(pstimer->arg);

}

// only operation once, when overflow more times.

do{

pstimer->atv.tv_sec += pstimer->itv.tv_sec;

pstimer->atv.tv_usec += pstimer->itv.tv_usec;

} while(max_time(&pstimer->atv, &tv) < 0);

// } else {

// break;

}

// get next itimer

if(min_time(pstimer->atv, *ptv_min)){

ptv_min = &(pstimer->atv);

}

}

memset(&it, 0, sizeof(it));

// it.it_value.tv_sec = ptv_min->tv_sec - tv.tv_sec;

// it.it_value.tv_usec = ptv_min->tv_usec - tv.tv_usec;

TV_MINUS(*ptv_min, tv, it.it_value);

ret = setitimer(ITIMER_REAL, &it, NULL);

if(ret < 0){

perror("setitimer");

}

printf("process SIGALRM, next time is %ld:%ld\n", it.it_value.tv_sec, it.it_value.tv_usec);

}

int timer_add(long sec, long usec, void (*stimer_func)(void *arg), void *arg)

{

struct signal_timer *pstimer = (struct signal_timer*)malloc(sizeof(struct signal_timer));

struct timespec ts;

memset(pstimer, 0, sizeof(*pstimer));

pstimer->id = g_id++;

pstimer->itv.tv_sec = sec;

pstimer->itv.tv_usec = usec;

pstimer->stimer_handler = stimer_func;

if(arg){

pstimer->arg = arg;

}else {

pstimer->arg = pstimer;

}

list_add(&(pstimer->list_timer), &g_signal_list);

clock_gettime(CLOCK_MONOTONIC_RAW, &ts);

pstimer->atv.tv_sec += ts.tv_sec;

pstimer->atv.tv_usec += ts.tv_nsec / 1000;

return pstimer->id;

}

void timer_del(int id, int is_free)

{

struct signal_timer *pstimer = NULL;

list_for_each_entry(pstimer, &g_signal_list, list_timer){

if(pstimer->id == id){

list_del(&(pstimer->list_timer));

printf("----delete timerid is %d\n", pstimer->id);

if(is_free){

free(pstimer);

}

break;

}

}

}

int timer_init(void)

{

INIT_LIST_HEAD(&g_signal_list);

struct sigaction act;

int ret = 0;

// memset(&act, 0, sizeof(act));

sigemptyset(&act.sa_mask);

act.sa_handler = alarm_handler;

act.sa_flags = 0;

ret = sigaction(SIGALRM, &act, NULL);

if(ret < 0){

perror("sigaction");

return -1;

}

g_id = TIMERID_FIRST ;

return 0;

}

void timer_destroy(void)

{

struct signal_timer *pstimer = NULL;

while(! list_empty((&g_signal_list)->next)){

list_del((&g_signal_list)->next);

pstimer = container_of((&g_signal_list)->next, struct signal_timer, list_timer);

free(pstimer);

}

}

void timer_printf(void *arg)

{

if(arg){

struct signal_timer *pstimer = (struct signal_timer*)arg;

printf("timerid:%d, aim time: %ld:%ld\n", pstimer->id, pstimer->atv.tv_sec, pstimer->atv.tv_usec);

} else {

printf("timerid is %d\n", g_id);

}

}

int main(int argc, char **argv)

{

int tid1 = 0, tid2 = 0, tid3 = 0;

int i = 0;

signal(SIGPIPE, SIG_IGN);

timer_init();

tid1 = timer_add(2, 0, timer_printf, NULL);

tid2 = timer_add(3, 0, timer_printf, NULL);

tid3 = timer_add(5, 0, timer_printf, NULL);

alarm(1);

while(1){

sleep(1);

printf("sleep 1s\n");

i++;

if(i%3 == 0) timer_del(tid1, true);

if(i%7 == 0) timer_del(tid2, true);

if(i%9 == 0) timer_del(tid3, true);

}

timer_destroy();

return 0;

}

运行：

timerid:102, aim time: 468486:907381

timerid:101, aim time: 468486:907380

timerid:100, aim time: 468486:907380

process SIGALRM, next time is 0:999678

sleep 1s

timerid:100, aim time: 468488:907380

process SIGALRM, next time is 0:998577

sleep 1s

timerid:101, aim time: 468489:907380

process SIGALRM, next time is 0:999371

sleep 1s

----delete timerid is 100

process SIGALRM, next time is 0:999003

sleep 1s

timerid:102, aim time: 468491:907381

process SIGALRM, next time is 0:998901

sleep 1s

timerid:101, aim time: 468492:907380

process SIGALRM, next time is 2:998319

sleep 1s

sleep 1s

----delete timerid is 101

sleep 1s

process SIGALRM, next time is 0:999768

sleep 1s

----delete timerid is 102

sleep 1s

sleep 1s

sleep 1s

sleep 1s