linux系统中的定时器
概论
不管是用户空间的程序开发，还是内核空间的程序开发，很多时候都需要有定时器的支持，定时器属于程序开发中的基本组件。定时器一般按照使用场景分为两种类型：
1.Single-Shot Timer
2.Repeating Timer
其中第一种定时器，从注册到终止只执行一次，而第二种定时器，在每次执行完以后，自动重新开始。本质上，可以认为 Repeating Timer 是在 Single-Shot Timer 终止之后，再次注册到定时器系统里的 Single-Shot Timer，因此，在支持 Single-Shot Timer 的基础上支持 Repeating Timer 并不算特别的复杂。
Linux定时器
2.4内核版本linux
结构体：
struct itimerval {
struct timeval it_interval; /* next value */
struct timeval it_value; /* current value */
};
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
user api函数：
#include <sys/time.h>
int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value);
传入参数：
which：
ITIMER_REAL 以实时时间 (real time) 递减，在到期之后发送 SIGALRM 信号
ITIMER_VIRTUAL 仅进程在用户空间执行时递减，在到期之后发送 SIGVTALRM 信号
ITIMER_PROF 进程在用户空间执行以及内核为该进程服务时 ( 典型如完成一个系统调用 ) 都会递减，与 ITIMER_VIRTUAL 共用时可度量该应用在内核空间和用户空间的时间消耗情况，在到期之后发送 SIGPROF 信号
new_value：
新设置的定时器时间参数。
old_value：
返回的旧的定时器时间。
setitimer 能够在 timer 到期之后，自动再次启动自己，因此，用它来解决 Single-Shot Timer 和 Repeating Timer 的问题显得很简单。
2.6 内核版本linux
除了上面提到的接口，2.6版本内核以后，都增加了POSIX timer接口API。
#include <signal.h>
#include <time.h>
int timer_create(clockid_t clockid, struct sigevent *evp,timer_t *timerid);
int timer_settime(timer_t timerid, int flags, const struct itimerspec *new_value, struct itimerspec * old_value);
int timer_gettime(timer_t timerid, struct itimerspec *curr_value);
int timer_getoverrun(timer_t timerid);
int timer_delete(timer_t timerid);
这套接口是为了让操作系统对实时有更好的支持，在链接时需要指定 -lrt 。
timer_create: 创建了一个定时器。
timer_settime: 启动或者停止一个定时器。
timer_gettime: 返回到下一次到期的剩余时间值和定时器定义的时间间隔。出现该接口的原因是，如果用户定义了一个 1ms 的定时器，可能当时系统负荷很重，导致该定时器实际山 10ms 后才超时，这种情况下，overrun=9ms 。
timer_getoverrun: 返回上次定时器到期时超限值。
timer_delete: 停止并删除一个定时器。
上面最重要的接口是timer_create，其中，clockid 表明了要使用的时钟类型，在 POSIX 中要求必须实现 CLOCK_REALTIME 类型的时钟。 evp 参数指明了在定时到期后，调用者被通知的方式。该结构体定义如下 :
union sigval {
int sival_int;
void *sival_ptr;
};
struct sigevent {
int sigev_notify; /* Notification method */
int sigev_signo; /* Timer expiration signal */
union sigval sigev_value;
/* Value accompanying signal or
void (*sigev_notify_function) (union sigval);
/* Function used for thread
notifications (SIGEV_THREAD) */
void *sigev_notify_attributes;
/* Attributes for notification thread
(SIGEV_THREAD) */
pid_t sigev_notify_thread_id;
/* ID of thread to signal (SIGEV_THREAD_ID) */
};
sigev_notify 指明了通知的方式 :
SIGEV_NONE
当定时器到期时，不发送异步通知，但该定时器的运行进度可以使用 timer_gettime监测。
SIGEV_SIGNAL
当定时器到期时，发送 sigev_signo 指定的信号。
SIGEV_THREAD
当定时器到期时，以 sigev_notify_function 开始一个新的线程。该函数使用 sigev_value 作为其参数，当 sigev_notify_attributes 非空，则制定该线程的属性。注意，由于 Linux 上线程的特殊性，这个功能实际上是由 glibc 和内核一起实现的。
SIGEV_THREAD_ID (Linux-specific)
仅推荐在实现线程库时候使用。
如果 evp 为空的话，则该函数的行为等效于：sigev_notify = SIGEV_SIGNAL，sigev_signo = SIGVTALRM，sigev_value.sival_int = timer ID 。
POSIX timer 接口支持在一个进程中同时拥有多个定时器实例。但是需要注意的是，POSIX timer 接口只在进程环境下才有意义 ，并不适合多线程环境。因此，Linux 提供了基于文件描述符的相关定时器接口：
#include <sys/timerfd.h>
int timerfd_create(int clockid, int flags);
int timerfd_settime(int fd, int flags,
const struct itimerspec *new_value,
struct itimerspec *old_value);
int timerfd_gettime(int fd, struct itimerspec *curr_value);
这样，由于基于文件描述符，使得该接口可以支持 select，poll 等异步接口，使得定时器的实现和使用更加的方便，它们的使用比 POSIX timer 更加的灵活。
自定义定时器
为了同时支持2.4以及2.6版本以上的内核环境，我们可以考虑自己实现定时器来进行统一管理。
在接下来将实现一个简单的定时器模型，将基于上面提到的setitimer接口来实现，此接口在linux系统中都存在。
为什么要实现自定义定时器，首先，2.4内核中没有posix timer接口，而setitimer接口只能允许一个进程中存在一个定时器，那么当我们需要在进程中使用多个定时器时就束手无措，另外也是为了程序上的兼容，所以我们接下来将介绍如何实现自己的定时器。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>
#include <stdbool.h>
#include <string.h>
#include "list.h"
/** * @file name: timer.c * @author:xhc * @date:2016.5.17 * */
#define MAX_TIMER_NUM 50
typedef void (*callback)(int id, void *data, int len);
typedef void (*SIG_FUNC)(int signo);
typedef struct timer{
struct list_head node;
int interval; /*timer interval(second)*/
int elapse; /*timer count*/
callback cb; /*call back function*/
void *user; /*user data*/
int len;
int id; /*timerid*/
}timer_node_t;
struct timer_list{
struct list_head head;
int num;
int size;
void (*sighandler_old)(int);
void (*sighandler)(int);
struct itimerval ovalue;
struct itimerval value;
};
/** * Local data */
static struct timer_list *timer_list = NULL;
static void sig_func(int signo)
{
struct list_head *node;
struct list_head *tmp;
timer_node_t *timer;
if(list_empty(&timer_list->head) == true){
return;
}
list_for_each_safe(node, tmp, &timer_list->head) {
timer = list_entry(node, struct timer, node);
timer->elapse++;
if(timer->elapse >= timer->interval) {
timer->elapse = 0;
timer->cb(timer->id, timer->user, timer->len);
}
}
}
/** *Create timer list *@param */
struct timer_list *create_timer_list(int count)
{
int ret = 0;
struct timer_list *ptr = NULL;
if(count <=0 || count > MAX_TIMER_NUM) {
printf("the timer max number too big, MAX num is %d.\n", MAX_TIMER_NUM);
return NULL;
}
ptr = (struct timer_list *)malloc(sizeof(struct timer_list));
memset(ptr, 0, sizeof(struct timer_list));
INIT_LIST_HEAD(&ptr->head);
ptr->size = count;
/* Register our internal signal handler and store old signal handler */
if ((ptr->sighandler_old = signal(SIGALRM, sig_func)) == SIG_ERR) {
goto err_out;
}
ptr->sighandler = sig_func;
ptr->value.it_value.tv_sec = 1; /*for firt timeout*/
ptr->value.it_value.tv_usec = 0;
ptr->value.it_interval.tv_sec = 1; /*for tick reload*/
ptr->value.it_interval.tv_usec = 0;
ret = setitimer(ITIMER_REAL, &ptr->value, &ptr->ovalue);
if (ret < 0)
goto err_out;
return ptr;
err_out:
printf("create_timer_list error\n");
free(ptr);
return NULL;
}
/** * Destroy the timer list. * * @return 0 means ok, the other means fail. */
int destroy_timer(struct timer_list *list)
{
struct timer *node = NULL;
signal(SIGALRM, list->sighandler_old);
setitimer(ITIMER_REAL, &list->ovalue, &list->value);
if(list_empty(&list->head) == false){
struct list_head *node;
struct list_head *tmp;
timer_node_t *timer;
list_for_each_safe(node, tmp, &list->head) {
timer = list_entry(node, struct timer, node);
list_del(node);
free(timer->user);
free(timer);
timer = NULL;
}
}
free(list);
return 0;
}
/** * Add a timer to timer list. * * @param interval The timer interval(second). * @param cb When cb!= NULL and timer expiry, call it. * @param user_data Callback's param. * @param len The length of the user_data. * * @return if == -1, add timer fail. */
int add_timer(int interval, callback cb, void *user_data, int len)
{
struct timer *node = NULL;
if (cb == NULL || interval <= 0) {
return -1;
}
if(timer_list->num < timer_list->size) {
timer_list->num++;
} else {
return -1;
}
if((node = malloc(sizeof(struct timer))) == NULL) {
return -1;
}
if(user_data != NULL || len != 0) {
node->user = malloc(len);
memcpy(node->user, user_data, len);
node->len = len;
}
node->cb = cb;
node->interval = interval;
node->elapse = 0;
node->id = timer_list->num;
list_add_tail(&node->node, &timer_list->head);
return node->id;
}
int del_timer(int timer_id)
{
struct list_head *node;
struct list_head *tmp;
timer_node_t *timer;
if(timer_list == NULL) {
return -1;
}
if(list_empty(&timer_list->head) == true){
return -1;
}
list_for_each_safe(node, tmp, &timer_list->head) {
timer = list_entry(node, struct timer, node);
if (timer->id == timer_id){
list_del(node);
free(timer->user);
free(timer);
return 0;
}
timer = NULL;
}
return -1;
}
/****************demo*******************/
void timer_test_callback(int id, void *data, int len)
{
int *user = (int *)data;
printf("timer id is :%d\n",id);
printf("data is : %d\n", *user);
printf("print this for every 5 sec!!!\n");
user[0]++;
}
int main()
{
int timer_id = -1;
int count = 0;
timer_list = create_timer_list(10);
timer_id = add_timer(5, timer_test_callback, &count, 4);
while(count++ < 20)
sleep(1);
del_timer(timer_id);
destroy_timer(timer_list);
}
以上就是我们自己实现的timer管理器，还是有待优化的地方，比如采用排序链表，来优化查找复杂度，感兴趣的读者可以自己尝试修改。