linux 定时器资料整理

1、sleep，usleep和nanosleep

sleep()和nanosleep()都是使进程睡眠一段时间后被唤醒，但是二者的实现完全不同。
Linux中并没有提供系统调用sleep()，sleep()是在库函数中实现的，它是通过调用alarm()来设定报警时间，调用sigsuspend()将进程挂起在信号SIGALARM上，sleep()只能精确到秒级上。

    nanosleep()则是Linux中的系统调用，它是使用定时器来实现的，该调用使调用进程睡眠，并往定时器队列上加入一个timer_list型定时器，time_list结构里包括唤醒时间以及唤醒后执行的函数，通过nanosleep()加入的定时器的执行函数仅仅完成唤醒当前进程的功能。系统通过一定的机制定时检查这些队列（比如通过系统调用陷入核心后，从核心返回用户态前，要检查当前进程的时间片是否已经耗尽，如果是则调用schedule()函数重新调度，该函数中就会检查定时器队列，另外慢中断返回前也会做此检查），如果定时时间已超过，则执行定时器指定的函数唤醒调用进程。当然，由于系统时间片可能丢失，所以nanosleep()精度也不是很高。

alarm()也是通过定时器实现的，但是其精度只精确到秒级，另外，它设置的定时器执行函数是在指定时间向当前进程发送SIGALRM信号。

 

2、使用信号量SIGALRM + alarm()

alarm方式虽然很好，但这种方式的精度能达到1秒，是无法低于1秒的精度。

man alarm

测试代码 

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void sigalrm_fn(int sig)
{
    printf("alarm!\n");
    alarm(2);
    return;
}
int main(void)
{
    signal(SIGALRM,sigalrm_fn);
    alarm(2);
    while(1)
    pause();
}

3、setitimer   

setitmer 和 alarm 共用同一个信号 SIGALRM ，setitmer 精度能达到us级

man setitimer 

#include <stdio.h>
#include <time.h>
#include <sys/time.h>
#include <stdlib.h>
#include <signal.h>
int count = 0;
void set_timer()
{
        struct itimerval itv, oldtv;
        itv.it_interval.tv_sec = 5;
        itv.it_interval.tv_usec = 0;
        itv.it_value.tv_sec = 5;
        itv.it_value.tv_usec = 0;
  
 
        setitimer(ITIMER_REAL, &itv, &oldtv);
}
 
void sigalrm_handler(int sig)
{
        count++;
        printf("timer signal.. %d\n", count);
}
 
int main()
{
        signal(SIGALRM, sigalrm_handler);
        set_timer();
        while (count < 1000)
        {}
        exit(0);
}

4、使用RTC机制

man rtc

RTC机制利用系统硬件提供的Real Time Clock机制，通过读取RTC硬件/dev/rtc，通过ioctl()设置RTC频率，代码如下：

#include <stdio.h>
#include <linux/rtc.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
 
int main(int argc, char* argv[])
{
    unsigned long i = 0;
    unsigned long data = 0;
    int retval = 0;
    int fd = open ("/dev/rtc", O_RDONLY);
    
    if(fd < 0)
    {
        perror("open");
        exit(errno);
    }
    
    /*Set the freq as 4Hz*/
    if(ioctl(fd, RTC_IRQP_SET, 4) < 0)
    {
        perror("ioctl(RTC_IRQP_SET)");
        close(fd);
        exit(errno);
    }
    /* Enable periodic interrupts */
    if(ioctl(fd, RTC_PIE_ON, 0) < 0)
    {
        perror("ioctl(RTC_PIE_ON)");
        close(fd);
        exit(errno);
    }
    
    for(i = 0; i < 100; i++)
    {
        if(read(fd, &data, sizeof(unsigned long)) < 0)
        {
            perror("read");
            close(fd);
            exit(errno);
            
        }
        //printf("data %d\n", data);
        printf("timer\n");
    }
    /* Disable periodic interrupts */
    ioctl(fd, RTC_PIE_OFF, 0);
    close(fd);
    
    return 0;
}

 rtc 定时器阻塞

5、使用select()

man select

能精确到1us.通过使用select()，来设置定时器；原理利用select()方法的第5个参数，第一个参数设置为0，三个文件描述符集都设置为NULL，第5个参数为时间结构体，代码如下：

#include <sys/time.h>
#include <sys/select.h>
#include <time.h>
#include <stdio.h>
 
/*seconds: the seconds; mseconds: the micro seconds*/
void setTimer(int seconds, int mseconds)
{
    struct timeval temp;
    
    temp.tv_sec = seconds;
    temp.tv_usec = mseconds * 1000;
    
    select(0, NULL, NULL, NULL, &temp);
    printf("timer\n");
    
    return ;
}
 
int main()
{
    int i;
    
    for(i = 0 ; i < 100; i++)
        setTimer(1, 0);
    
    return 0;
}

select 是阻塞的

6、POSIX  timer_create

man timer_create

1）采用新线程派驻的方式 （注： 编译时 需加上 -lrt）

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <time.h>
#include <error.h>
#include <errno.h>
#include <string.h>
 
 
void timer_thread(union sigval v)  
{  
    printf("timer_thread function! %d\n", v.sival_int);  
}  
 
int init_timer(timer_t *timerid, struct sigevent *evp, struct itimerspec *it)
{
    if ( !evp || !it )
        return -1;
 
    memset(evp, 0, sizeof(struct sigevent));   //清零初始化  
  
    evp->sigev_value.sival_int = 111;        //也是标识定时器的，这和timerid有什么区别？回调函数可以获得  
    evp->sigev_notify = SIGEV_THREAD;        //线程通知的方式，派驻新线程  
    evp->sigev_notify_function = timer_thread;   //线程函数地址  
 
    if (timer_create(CLOCK_REALTIME, evp, timerid) == -1)  
    {  
        perror("fail to timer_create");  
        return -1;;  
    }  
 
    printf("timer_create timerid = %d\n", *timerid);
    it->it_interval.tv_sec = 1;  // 后续按照该时间间隔 
    it->it_interval.tv_nsec = 0;  
    it->it_value.tv_sec = 3;     // 最初开始时间间隔 
    it->it_value.tv_nsec = 0;  
 
    return 0;
}
 
int start_timer(timer_t *timerid, struct itimerspec *it)
{
    if (it == NULL){
        return -1;
    }
    if (timer_settime(*timerid, 0, it, NULL) == -1)  
    {  
        perror("fail to timer_settime");  
        return -1;
    }  
    
    return 0;
}
 
void thread_func(void *param)
{
    int *a = (int *)param;
    while(1){
        sleep(1);
        printf("This is thread..\n");
    }
 
    *a = 100;
    printf("param = %d\n", *a);
}
 
int main(int argc, const char *argv[])
{
    pid_t pid = 0;
    pthread_t thread;
    timer_t timerid = 0;
    int ret;
    struct sigevent evp;  
    struct itimerspec it;  
 
    int a = 10;    
#if 0
 
    int ret = init_timer(&timerid, &evp, &it);
    if (ret < 0){
        printf("init_timer failed\n");
        return -1;
    }
#endif
  
    if ((pid = fork()) < 0)
    {
        printf("fork failed.\n");
        return -1;
    }
    else if ( pid == 0){
        printf("child proc..\n");
 
        ret = pthread_create(&thread, NULL, thread_func, &a);
 
        int ret = init_timer(&timerid, &evp, &it);
        if (ret < 0){
            printf("init_timer failed\n");
            return -1;
        }
        sleep(2);
        printf("child timer_Id addr = %d\n", timerid);
        start_timer(&timerid, &it);
 
        sleep(10);
        exit(0);
    }
    else{
        printf("I'm parent proc..\n");
        printf("parent timer_Id addr = %d\n", timerid);
        printf("pthread_id = %d\n", thread);
        do {
            ret = waitpid(pid, NULL, WNOHANG);
            if (ret == 0){
                printf("No child exit\n");
                sleep(2);
            }
            else if (ret == pid){
                printf("Successly get child %d\n", pid);
            }
            else
                printf("something error\n");
        }while(ret == 0);
    
        /*ret = waitpid(pid, NULL, 0);*/
        /*if (ret == pid)*/
            /*printf("successly get child %d\n", pid);*/
 
    }
    pause();
    return 0;
}

2） 采用通知方式为信号（signal）的处理方式

#include<stdio.h>
#include<signal.h>
#include<time.h>
#include<string.h>
 
void handle()  
{  
    time_t t;  
    char p[32];  
  
    time(&t);  
    strftime(p, sizeof(p), "%T", localtime(&t));  
  
    printf("time is %s\n", p);  
}  
  
  
  
int main()  
{  
    struct sigevent evp;  
    struct itimerspec ts;  
    timer_t timer;  
    int ret;  
  
    memset(&evp, 0, sizeof(struct sigevent));
 
    evp.sigev_value.sival_ptr = &timer;  
    evp.sigev_notify = SIGEV_SIGNAL;  
    evp.sigev_signo = SIGUSR1;  
    signal(SIGUSR1, handle);  
  
    ret = timer_create(CLOCK_REALTIME, &evp, &timer);  
    if( ret )   
        perror("timer_create");  
  
    ts.it_interval.tv_sec = 1;  
    ts.it_interval.tv_nsec = 0;  
    ts.it_value.tv_sec = 3;  
    ts.it_value.tv_nsec = 0;  
  
    ret = timer_settime(timer, 0, &ts, NULL);  
    if( ret )   
    perror("timer_settime");  
  
    while(1);

} 

3） 信号为signaction处理函数 :

#include <stdio.h>  
#include <time.h>  
#include <stdlib.h>  
#include <signal.h>  
#include <string.h>  
#include <unistd.h>  
  
#define CLOCKID CLOCK_REALTIME  
  
void sig_handler(int signo)  
{  
    printf("timer_signal function! %d\n", signo);  
}  
  
int main()  
{  
    //XXX int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);  
    // signum--指定的信号编号，可以指定SIGKILL和SIGSTOP以外的所有信号编号  
    // act结构体--设置信号编号为signum的处理方式  
    // oldact结构体--保存上次的处理方式  
    //  
    // struct sigaction   
    // {  
    // void (*sa_handler)(int);         //信号响应函数地址  
    // void (*sa_sigaction)(int, siginfo_t *, void *);   //但sa_flags为SA——SIGINFO时才使用  
    // sigset_t sa_mask;         //说明一个信号集在调用捕捉函数之前，会加入进程的屏蔽中，当捕捉函数返回时，还原  
    // int sa_flags;  
    // void (*sa_restorer)(void);   //未用  
    // };  
    //  
    timer_t timerid;  
    struct sigevent evp;  
  
    struct sigaction act;  
    memset(&act, 0, sizeof(act));  
    act.sa_handler = sig_handler;  
    act.sa_flags = 0;  
  
    // XXX int sigaddset(sigset_t *set, int signum);  //将signum指定的信号加入set信号集  
    // XXX int sigemptyset(sigset_t *set);          //初始化信号集  
      
    sigemptyset(&act.sa_mask);  
  
    if (sigaction(SIGUSR1, &act, NULL) == -1)  
    {  
        perror("fail to sigaction");  
        exit(-1);  
    }  
  
    memset(&evp, 0, sizeof(struct sigevent));  
    evp.sigev_signo = SIGUSR1;  
    evp.sigev_notify = SIGEV_SIGNAL;  
    if (timer_create(CLOCK_REALTIME, &evp, &timerid) == -1)  
    {  
        perror("fail to timer_create");  
        exit(-1);  
    }  
  
    struct itimerspec it;  
    it.it_interval.tv_sec = 2;  
    it.it_interval.tv_nsec = 0;  
    it.it_value.tv_sec = 1;  
    it.it_value.tv_nsec = 0;  
    if (timer_settime(timerid, 0, &it, 0) == -1)  
    {  
        perror("fail to timer_settime");  
        exit(-1);  
    }  
    while(1)
    pause();  
  
    return 0;  
}  

参考网址 LInux下几种定时器的比较和使用

参考网址 linux定时器的实现方法

参考网址： Linux内核时钟系统和定时器实现

参考网址：linux下定时器timer_create()的使用