[linux c/c++] linux下定时器的使用

前言：

linux下，定时器有三种实现：

1）使用posix的定时器，相关接口为 timer_create

2）使用alarm函数进行计时，alarm函数计时满后会发送ALARM信号，注册信号处理函数即可；

3）使用linux内核的原生timer，需要引入内核模块，头文件为 linux/timer.h

C++ 封装posix：

    template <typename T>
    class MyTimer
    {
    public:
        typedef void (*TimerHandler)(union sigval);
    public:
        MyTimer();
        ~MyTimer();
        void Init(bool triggeronstart,long long interval,TimerHandler routine,std::shared_ptr<T> routineArgs,std::string desc);
        void Delete();

    public:
        std::string m_desc;

    private:
        TimerHandler m_routine;
        bool m_triggerOnStart = false;
        long long m_interval;    //ms
        timer_t m_timerid;
        std::shared_ptr<T> m_routineArgs;
    };

    template <typename T>
    MyTimer<T>::MyTimer()
    {

    }

    template <typename T>
    MyTimer<T>::~MyTimer()
    {

    }

    template <typename T>
    void MyTimer<T>::Init(bool triggeronstart,long long interval,TimerHandler routine,std::shared_ptr<T> routineArgs,std::string desc)
    {
        m_triggerOnStart = triggeronstart;
        m_interval = interval;
        m_routine = routine;
        m_routineArgs = routineArgs;
        m_desc = desc;

        int ret = 0;
        struct sigevent sev;
        memset(&sev, 0, sizeof(struct sigevent));
        sev.sigev_notify = SIGEV_THREAD;
        sev.sigev_notify_function = m_routine;
        sev.sigev_value.sival_ptr = m_routineArgs.get();
        if(ret = timer_create(CLOCK_REALTIME,&sev,&m_timerid))
        {
            assert(ret);
        }

        struct itimerspec its;
        its.it_interval.tv_sec = m_interval/1000;
        its.it_interval.tv_nsec = (m_interval%1000)*1000000;
        if(m_triggerOnStart){
            its.it_value.tv_sec = 0;
            its.it_value.tv_nsec = 0;
        }else{
            its.it_value.tv_sec = its.it_interval.tv_sec;
            its.it_value.tv_nsec = its.it_interval.tv_nsec;
        }

        if(ret = timer_settime(m_timerid, 0, &its, NULL))
        {
            assert(ret);
        }
    }

    template <typename T>
    void MyTimer<T>::Delete()
    {
        timer_delete(m_timerid);
    }

posix：

以下代码使用回调函数作为定时器触发处理手段。

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <time.h>
#include <signal.h>

struct param{
	int i;
	char c;
}p;

int cnt;

void callback(union sigval v){
	struct param * pa = (struct param *)v.sival_ptr;
	printf("callback %c\n",pa->c);
}

int main(int argc,char ** argv)
{
restart:
	cnt = 0;
	timer_t timerid;
	struct sigevent sev;
	memset(&sev, 0, sizeof(struct sigevent));
	
	p.i = 100;
	p.c = 'c';
	
	sev.sigev_notify = SIGEV_THREAD;
	sev.sigev_notify_function = callback;
	sev.sigev_value.sival_ptr = &p;
	
	if(-1 == timer_create(CLOCK_REALTIME,&sev,&timerid)){
		printf("timer_create fail");
	}
	
    struct itimerspec its;
    its.it_value.tv_sec = 1;
    its.it_value.tv_nsec = 0;
    its.it_interval.tv_sec = 1;
    its.it_interval.tv_nsec = 0;

	if(-1==timer_settime(timerid, 0, &its, NULL)){
		printf("timer_settime fail");
	}
	
	while(1)
	{
		sleep(10);
		cnt++;
		if(cnt == 2){	// 20秒后关闭定时器
			timer_delete(timerid);
		}
		else if(cnt == 4){	// 40秒后重新创建定时器
			goto restart;
		}
	}
}

alarm：

//功能描述：在5s内轮询产生的随机数(1s生产一个随机数)，判断随机数是不是100的整数倍，如果是，则输出定时器剩余时间，如果不是，继续

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <setjmp.h>

enum{
	TIMER_HANDLER=1,	//来自中断处理函数跳转点
};

#define SAVE_SIGMASK 1

long lrandom;	//随机数
int remain;	//剩余时间

void endup(void);
void do_clean(void);
void timer_handler(void);
jmp_buf sv_p1;


int main(int argc,char ** argv)
{
	int interval=5;//多久中断超时一次
	int iRet;	
	signal(SIGALRM,(void *)timer_handler);

	//setjmp(sv_p1); //不使用
	iRet = sigsetjmp(sv_p1,SAVE_SIGMASK);
	if(iRet == TIMER_HANDLER)
	{
		//从中断处理函数跳过来的
		printf("jump from void timer_handler(void)\n");
	}
	else
	{
		//从其他地方跳过来的
	}
	
	alarm(interval);//开始计时
	while(1)
	{
		sleep(1);
		lrandom=random();
		int yushu;
		yushu=lrandom%100;//求余数
		printf("yushu = [%ld],lrandom = [%ld]\n",yushu,lrandom);
		if(yushu==0)
		{
			//整除了
			remain = alarm(0);//cancle counter,return remain seconds
			printf("got a number which can be divided by 100 , %d seconds remaining,num is [%ld]\n",remain,lrandom);
			alarm(interval);	//重置定时器
		}
	}
}

void timer_handler(void)
{
	printf("time out\n");
	//1.end of process
	//endup();
	//2.jump to somewhere,goto 只能在当前栈内跳转，栈外跳转使用longjmp系列，
	//这里使用siglongjmp和sigsetjmp，因为使用longjmp和setjmp在入中断处理函数后，
	//会自动把中断掩码清0，这样可屏蔽中断就全都被关闭了，下次再满足中断条件也不会入中断了

	printf("goto save point 1\n");
	//longjmp(sv_p1,TIMER_HANDLER)  //不使用
	siglongjmp(sv_p1,TIMER_HANDLER);//TIMER_HANDLER为返回值，这个值作为sigsetjmp的返回值，用来判断跳转点
}

void endup(void)
{
	do_clean();
	exit(-1);
}

void do_clean(void)
{

}

原生定时器(saw timer)：

#include <linux/timer.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

static inline void Start_timer(struct timer_list *timer,unsigned long msec);
static inline void Init_timer(struct timer_list *timer,Handler routine,unsigned long argument);
static inline void Cancle_timer(struct timer_list *timer);

typedef void (*Handler) (void *);

struct timer_class{
        struct timer_list identity;
        char * desc;
        unsigned long interval;

        Handler routine;
}timer1;


int main (int argc,char ** argv)
{
        timer1.desc="timer used for xxx\n";
        timer1.interval=1000;
        timer1.routine=(Handler)time_out_handler;

        //1.INIT A TIMER
        Init_timer(&(timer1.identity),timer1.routine,(unsigned long)timer1);
        //2.START A TIMER
        Start_timer(&(timer1.identity),timer1.interval);
        //3.have a sleep
        while(1) sleep(1);
}

void time_out_handler(struct timer_class *argu)
{
        arug=(struct timer_calss *)argu;
        //restart timer
        Start_timer(argu->interval);
        argu->interval *=2;
//      printf("time out! timer set to %ld\n",argu->interval);
}


static inline void Start_timer(struct timer_list *timer,unsigned long msec)
{
        mod_timer(timer,jiffies + msec_to_jiffies(msec) + 1);
}

static inline void Init_timer(struct timer_list *timer,Handler routine,unsigned long argument)
{
        setup_timer(timer,routine,argument);
}

static inline void Cancle_timer(struct timer_list *timer)
{
        del_timer_sync(timer);
}