Linux定时器的实现

#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 = 0;
        itv.it_interval.tv_usec = 1000;
        itv.it_value.tv_sec = 0;
        itv.it_value.tv_usec = 1000;
        setitimer(ITIMER_REAL, &itv, &oldtv);
}
void sigalrm_handler(int sig)
{
        count++;
}
int main( )
{
        signal(SIGALRM, sigalrm_handler);
        set_timer();
        while(count < 10000){
        }
        printf("count  = %d/n", count);
        exit(0);
}
setitimer函数的精度决定于系统时钟的分辨率，在我的系统中要40s才能返回，说明分辨率不到1ms。如果改成间隔10ms(10000us)的话，系统100s返回，很准确。一般操作系统的分辨率都为10ms。注意，信号会中断低速系统调用，所以这里用循环延迟，而不是用sleep之类的函数。

还有一种方法是基于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>
int main(void)
{
    int i, fd, retval, irqcount = 0;
    unsigned long tmp, data;
    fd = open ("/dev/rtc", O_RDONLY);
    if (fd ==  -1) {
      perror("/dev/rtc");
      exit(errno);
    }
    fprintf(stderr, "/n/tRTC Driver Test Example./n");
    /* Turn on update interrupts (one per second) */
    retval = ioctl(fd, RTC_UIE_ON, 0);
    if (retval == -1) {
      perror("ioctl");
      exit(errno);
    } 
    fprintf(stderr, "Counting 5 update (1/sec) interrupts from reading /dev/rtc:");
    fflush(stderr);
    for (i=1; i<6; i++) {
        /* This read will block */
        retval = read(fd, &data, sizeof(unsigned long));
        if (retval == -1) { 
           perror("read");
           exit(errno);
        }
        fprintf(stderr, " %d",i);
        fflush(stderr);
        irqcount++;
    }
    /* Turn off update interrupts */
    retval = ioctl(fd, RTC_UIE_OFF, 0);
    if (retval == -1) {
      perror("ioctl");
      exit(errno);
    }
    /* Read periodic IRQ rate */
    retval = ioctl(fd, RTC_IRQP_READ, &tmp); 
    if (retval == -1) { 
      perror("ioctl"); 
      exit(errno);
    }
    fprintf(stderr, "/nPeriodic IRQ rate was %ldHz./n", tmp);
    fprintf(stderr, "Counting 20 interrupts at:");
    fflush(stderr);
    /* The frequencies 128Hz, 256Hz, ... 8192Hz are only allowed for root. */
    for (tmp=2; tmp<=64; tmp*=2) {
      retval = ioctl(fd, RTC_IRQP_SET, tmp);
      if (retval == -1) {
          perror("ioctl");
          exit(errno);
      }
      fprintf(stderr, "/n%ldHz:/t", tmp);
      fflush(stderr);
      /* Enable periodic interrupts */
      retval = ioctl(fd, RTC_PIE_ON, 0);
      if (retval == -1) {
         perror("ioctl");
         exit(errno);
      }
      for (i=1; i<21; i++) {
       /* This blocks */ 
       retval = read(fd, &data, sizeof(unsigned long));
       if (retval == -1) {
           perror("read");
           exit(errno);
       } 
       fprintf(stderr, " %d",i);
       fflush(stderr);
       irqcount++;
       }
       /* Disable periodic interrupts */
       retval = ioctl(fd, RTC_PIE_OFF, 0);
       if (retval == -1) {
           perror("ioctl");
           exit(errno); 
       } 
    }
    fprintf(stderr, "/n/t *** Test complete ***/n");
    fprintf(stderr, "/nTyping /"cat /proc/interrupts/" will show %d more events on IRQ 8./n", irqcount);
    close(fd);
    return 0;
}
返回值是unsigned long型变量，低字节表示中断的类型(update-done, alarm-rang, or periodic)，其他字节表示从上次读以来产生的中断次数。注意在高频率或高负载的情况下，会出现interrupt pileup，即中断次数大于一次，所以当大于时钟中断频率（1000HZ）时应检查返回值。
这两种定时器的实现都无法在一个进程里面同时设置多个定时器，需要自己实现一个timer管理器。    

 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>  
#include <sys/time.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <signal.h>
#include <errno.h>

#define TRUE 1
#define FALSE 0
#define MUTEX 0

#define MAX_TIMERS 20 /* number of timers */
#define VERY_LONG_TIME {0x7FFFFFFF, 0} /* longest time possible */
typedef struct timeval TIME;  /* how time is actually stored */

struct timer {
int inuse;  /* TRUE if in use */
TIME time;  /* relative time to wait */
void (*callback)(void *);  /* callback function */
void *param; /* callback parameter */
} timers[MAX_TIMERS];  /* set of timers */
struct timer *timer_next = NULL;/* timer we expect to run down next */
TIME time_timer_set;  /* time when physical timer was set */
int semid;       /* semaphore set */
sigset_t newmask, oldmask; /* signal mask */

void timers_update();
void set_timer(TIME time);

int sem_init(int nsems,int flag)
{
int semid;
semid = semget(IPC_PRIVATE, nsems, flag);
if (semid == -1)
  perror("semget");
return semid;
}
int sem_setval(int semid, int semnum, int val)
{
if (val < 0)
  return -1;
semctl(semid, semnum, SETVAL, val);
return 0;
}
int sem_wait(int semid, int semnum)
{
struct sembuf sem;
int ret;
sem.sem_num = semnum;
sem.sem_op = -1;
sem.sem_flg = SEM_UNDO;
while(((ret=semop(semid, &sem, 1)) == -1) && (errno == EINTR));
if (ret == -1){
  perror("sem_wait");
  return -1;
}
else
  return 0;
}
int sem_signal(int semid, int semnum)
{
struct sembuf sem;
int ret;
sem.sem_num = semnum;
sem.sem_op = 1;
sem.sem_flg = SEM_UNDO;
while(((ret=semop(semid, &sem, 1)) == -1) && (errno == EINTR));
if (ret == -1){
  perror("sem_signal");
  return -1;
}
else
  return 0;
}
void sem_delete(int semid, int semnum)
{
semctl(semid, semnum, IPC_RMID);
}
int disable_interrupt()
{
if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) {
  perror("SIG_BLOCK");
  return -1;
} else {
  return 0;
}
}
int enable_interrupt()
{
if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0) {
  perror("SIG_SETMASK");
  return -1;
} else {
  return 0;
}
}
int time_now(TIME *time_val)
{
struct timezone tz;
int ret;
ret = gettimeofday(time_val, &tz);
return ret;
}
int time_after(TIME t1, TIME t2)
{
if ((t1.tv_sec - t2.tv_sec) > 0)
  return 1;
else if ((t1.tv_sec - t2.tv_sec) < 0)
  return -1;
else {
  if ((t1.tv_usec - t2.tv_usec) > 0)
   return 1;
  else if ((t1.tv_usec - t2.tv_usec) < 0)
   return -1;
  else
   return 0;
}
}
TIME subtract(TIME t1, TIME t2)
{
TIME tmp;
if ((t1.tv_usec - t2.tv_usec) < 0) {
  t1.tv_sec--;
  t1.tv_usec += 1000000;
  tmp.tv_sec = t1.tv_sec - t2.tv_sec;
  tmp.tv_usec = t1.tv_usec - t2.tv_usec;
} else {
  tmp.tv_sec = t1.tv_sec - t2.tv_sec;
  tmp.tv_usec = t1.tv_usec - t2.tv_usec;
}
return tmp;
}
TIME add(TIME t1, TIME t2)
{
TIME tmp;
if ((t1.tv_usec + t2.tv_usec) < 1000000) {
  tmp.tv_sec = t1.tv_sec + t2.tv_sec;
  tmp.tv_usec = t1.tv_usec + t2.tv_usec;
} else {
  tmp.tv_sec = t1.tv_sec + t2.tv_sec + 1;
  tmp.tv_usec = t1.tv_usec + t2.tv_usec - 1000000;
}
return tmp;
}
void timer_init(void)
{
struct timer *t;
for (t=timers;t<&timers[MAX_TIMERS];t++)
  t->inuse = FALSE;
}
void timer_unregister(struct timer *t)
{
TIME tn;
sem_wait(semid, MUTEX);
disable_interrupt();

if (!t->inuse) {
  enable_interrupt();
  sem_signal(semid, MUTEX);
  return;
}
t->inuse = FALSE;
/* check if we were waiting on this one */
if (t == timer_next) {
  if (time_now(&tn) < 0) {
   perror("time_now");
   enable_interrupt();
   sem_signal(semid, MUTEX);
   return;
  }
  timers_update(subtract(tn, time_timer_set));
  if (timer_next) {
   set_timer(timer_next->time);
   time_timer_set = tn;
  }
}
enable_interrupt();
sem_signal(semid, MUTEX);
}
void timers_update(TIME time)
{
static struct timer timer_last = {
  FALSE   /* in use */,
  VERY_LONG_TIME  /* time */,
  NULL   /* callback pointer */,
  NULL   /* callback param */
};
struct timer *t;
timer_next = &timer_last;
for (t=timers;t<&timers[MAX_TIMERS];t++) {
  if (t->inuse) {
   if (time_after(t->time, time) > 0) { /* unexpired */
    t->time = subtract(t->time, time);
    if (time_after(timer_next->time, t->time) > 0)
     timer_next = t;
   } else { /* expired */
    t->callback(t->param);
    t->inuse = FALSE; /* remove timer */
   }
  }
}
/* reset timer_next if no timers found */
if (!timer_next->inuse)
  timer_next = NULL;
}
struct timer *timer_register(TIME time, void (*callback)(void *), void *param)
{
struct timer *t;
TIME tn;
sem_wait(semid, MUTEX);
disable_interrupt();
for (t=timers;t<&timers[MAX_TIMERS];t++) {
  if (!t->inuse)
   break;
}
/* out of timers? */
if (t == &timers[MAX_TIMERS]) {
  enable_interrupt();
  sem_signal(semid, MUTEX);
  return NULL;
}
/* install new timer */
t->time = time;
t->callback = callback;
t->param = param;
if (time_now(&tn) < 0) {
  perror("time_now");
  enable_interrupt();
  sem_signal(semid, MUTEX);
  return NULL;
}
if (!timer_next) {
  /* no timers set at all, so this is shortest */
  time_timer_set = tn;
  timer_next = t;
  set_timer(timer_next->time);
} else {
  TIME new_time, last_time;
  new_time = add(time, tn);
  last_time = add(timer_next->time, time_timer_set);
  if (time_after(last_time, new_time) > 0){
   /* new timer is shorter than current one */
   timers_update(subtract(tn, time_timer_set));
   time_timer_set = tn;
   timer_next = t;
   set_timer(timer_next ->time);
  } else {
   /* new timer is longer than current one */
  }
}
t->inuse = TRUE;
enable_interrupt();
sem_signal(semid, MUTEX);
return t;
}

void set_timer(TIME time)
{
struct itimerval itv, oldtv;
itv.it_interval.tv_sec = 0;
itv.it_interval.tv_usec = 0;
itv.it_value.tv_sec = time.tv_sec;
itv.it_value.tv_usec = time.tv_usec;
setitimer(ITIMER_REAL, &itv, &oldtv);
}

void timer_interrupt_handler(int sig)
{
TIME tn;

printf("interrupt--------/n");
if (time_now(&tn) < 0) {
  perror("time_now");
  return;
}
timers_update(subtract(tn, time_timer_set));
/* start physical timer for next shortest time if one exists */
if (timer_next) {
  time_timer_set = tn;
  set_timer(timer_next ->time);
}
}
void timer_callback(void * param)
{
printf("%s callback/n", param);
}
int main( )
{
TIME time1 = {3,0},time2 = {5,0};
struct timer *p;

signal(SIGALRM, timer_interrupt_handler);
sigemptyset(&newmask);
sigaddset(&newmask, SIGALRM);

semid = sem_init(1, S_IRUSR|S_IWUSR);
if (semid == -1)
  exit(-1);
sem_setval(semid, MUTEX, 1);/*protect critical region*/

timer_init( );
timer_register(time1, timer_callback, "timer1");
p = timer_register(time1, timer_callback, "timer2");
timer_unregister(p);
timer_register(time2, timer_callback, "timer3");
getchar();
sem_delete(semid, MUTEX);

exit(0);
}