Linux定时器分析-源码sample

/*

 * time_test.c

 *

 *  Created on: 2015年6月3日

 *      Author: gcooq

 */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <signal.h>

#include <time.h>

#include <sys/time.h>

#include <sys/queue.h>

#define MAX_TIMER_NUM 1000

#define TIMER_START 1

#define TIMER_TICK 1   //一个tick滴答

#define INVALID_TIMER_ID  (-1)  //无效ID

#ifndef TRUE

#define TRUE 1

#endif

#ifndef FALSE

#define FALSE 0

#endif

typedef int  timer_id;  //计时器的ID

//当一个timer时间满时调用timer_expiry（）函数

typedef int timer_expiry(timer_id id,void *user_data,int len);

/*timer结构定义*/

struct timer{
LIST_ENTRY(timer)  entries;//list  entry
timer_id id;
//timer的ID
int  interval;                                         //timer间隔
int elapse;                                          //timer
timer_expiry *cb;               //如果时间满则调用
void *user_data;             //回调参数
int len;                               //user_data 长度

};

//timer list

struct timer_list{
LIST_HEAD(listheader,timer)  header;    //list header
int num;                                                    //计时器实体数目
int max_num;                                           //最大的实体数目
void  (*old_sigfunc)(int);                //保存之前的信号句柄Handler
void (*new_sigfunc)(int);            //信号句柄
struct itimerval ovalue;                  //旧的时间值
struct itimerval value;                 //our internal timer value

};

//函数操作

int  init_timer(int count);

int destroy_timer(void);

timer_id add_timer(int interval,timer_expiry *cb,void *user_data,int len);

int del_timer(timer_id id);

static struct timer_list timer_list;

static void sig_func(int signo);

//创建一个计时器

//返回值返回0表示成功

int init_timer(int count){

    int ret=0;

    if(count<=0||count>MAX_TIMER_NUM){

    printf("计时器最大数量为%d.\n",MAX_TIMER_NUM);

    return -1;//失败

    }

    memset(&timer_list,0,sizeof(struct timer_list));//分配内存

    LIST_INIT(&timer_list.header);

    timer_list.max_num=count;  //构造队列

    //注册内部信号句柄并且存储旧的信号句柄

    if((timer_list.old_sigfunc=signal(SIGALRM,sig_func))==SIG_ERR){

    return -1;

    }

    timer_list.new_sigfunc=sig_func;

    //设置内部计时器驱动多计时器和村粗就得计时器值

    timer_list.value.it_value.tv_sec=TIMER_START;

    timer_list.value.it_value.tv_usec=0;

    timer_list.value.it_interval.tv_sec=TIMER_TICK;

    timer_list.value.it_interval.tv_usec=0;

    ret=setitimer(ITIMER_REAL,&timer_list.value,&timer_list.ovalue);

    return ret;

}

//删除timerlist

int destroy_timer(void){
struct timer *node=NULL;
if((signal(SIGALRM,timer_list.old_sigfunc))==SIG_ERR){
return -1;
}
if((setitimer(ITIMER_REAL,&timer_list.ovalue,&timer_list.value))<0){
return -1;

}
while(!LIST_EMPTY(&timer_list.header)){ ///直到队列为空
node=LIST_FIRST(&timer_list.header);
LIST_REMOVE(node,entries);
//释放node
printf("移除 id %d\n",node->id);
free(node->user_data);
free(node);
}
memset(&timer_list,0,sizeof(struct timer_list));
return 0;

}

//增加计时器到计时器列表中

/*

 * cb cb!=NULL&&timer expiry,调用

 * 返回值为计时器ID  if==INVALID_TIMER ,添加失败

 * */

timer_id add_timer(int interval,timer_expiry *cb,void *user_data,int len){

struct timer *node=NULL;
if(cb==NULL||interval<=0){
return INVALID_TIMER_ID;
}
if(timer_list.num<timer_list.max_num){
timer_list.num++;
}
else{
return INVALID_TIMER_ID;//list加满了

}
if((node=malloc(sizeof(struct timer)))==NULL){
return INVALID_TIMER_ID;
}
if(user_data!=NULL||len!=0){
node->user_data=malloc(len);
memcpy(node->user_data,user_data,len);
node->len=len;
}
node->cb=cb;
node->interval=interval;
node->elapse=0;
node->id=timer_list.num;
LIST_INSERT_HEAD(&timer_list.header,node,entries);
return node->id;

}

//Delete  a timer from time list

int del_timer(timer_id id){

if(id<0||id>timer_list.max_num){
return -1;
}
struct timer *node=timer_list.header.lh_first;
for(;node!=NULL;node=node->entries.le_next){
printf("Total timer num 是 %d /timer id %d.\n",timer_list.num,id);
if(id==node->id){
LIST_REMOVE(node,entries);
timer_list.num--;
free(node->user_data);
free(node);
return 0;
}
}

//找不到计时器
return -1;

}

/*Tick Bookkeeping*/

static void sig_func(int signo){
struct timer *node=timer_list.header.lh_first;
for(;node!=NULL;node=node->entries.le_next){
node->elapse++;
if(node->elapse>=node->interval){ //说明tick大于允许的间隔时间大于或者等于的话将执行cb回调函数
node->elapse=0;
node->cb(node->id,node->user_data,node->len);
}
}

}

static char *fmt_time(char *tstr){
//格式化时间
time_t t;
t=time(NULL);
strcpy(tstr,ctime(&t));
tstr[strlen(tstr)-1]='\0';//结束字符
return tstr;

}

//单元测试

timer_id  id[3];

timer_id call_cnt=0;

int timer1_cb(timer_id id,void *arg,int len){
char tstr[200];
static int i,ret;

printf("欢迎 [%s] /id %d:timer1_cb is here.\n",fmt_time(tstr),id);
if(i>10){
ret=del_timer(id);
printf("timer1_cb:%s del_timer/id %d::ret=%d\n",fmt_time(tstr),id,ret);
}
i++;
call_cnt++;
return 0;

}

int timer2_cb(timer_id id,void *arg,int len){
char tstr[200];
static int i,ret;

printf("欢迎 [%s] /id %d:timer2_cb is here.\n",fmt_time(tstr),id);
if(i>10){
ret=del_timer(id);
printf("timer2_cb:%s del_timer/id %d::ret=%d\n",fmt_time(tstr),id,ret);
}
i++;
call_cnt++;
return 0;

}

int timer3_cb(timer_id id,void *arg,int len){
char tstr[200];
static int i,ret;
printf("欢迎 [%s] /id %d:timer3_cb is here.\n",fmt_time(tstr),id);
if(i>10){
ret=del_timer(id);
printf("timer1_cb:%s del_timer/id %d::ret=%d\n",fmt_time(tstr),id,ret);
}
i++;
call_cnt++;
return 0;

}

int main(void ){  //主函数
char arg[50];
char args[100];
char tstr[200];
int ret;
struct timespec time;
time.tv_sec=0;  //秒
time.tv_nsec=100000000;  //微毫秒

init_timer(MAX_TIMER_NUM);//初始化

id[0]=add_timer(1,timer1_cb,NULL,0);
printf("注册timer id[0]=%d\n",id[0]);

id[1]=add_timer(2,timer2_cb,arg,50);
printf("注册timer id[1]=%d\n",id[1]);

id[2]=add_timer(3,timer3_cb,args,100);
printf("注册timer id[2]=%d\n",id[2]);
while(1){
if(call_cnt>10){
break;
}
nanosleep(&time,NULL);
}
ret=destroy_timer();
printf("mainL%s destroy_timer,ret=%d\n",fmt_time(tstr),ret);
return 0;

}