linux 定时器

最新推荐文章于 2024-07-26 21:41:13 发布
转载 最新推荐文章于 2024-07-26 21:41:13 发布 · 1.1k 阅读 · 0
文章标签：

#linux #struct #任务 #null #signal #output

本文详细介绍了在Linux环境中使用内置定时器、alarm函数、系统时间差计算等方法实现周期性任务执行的原理和实践步骤，包括实时定时器、虚拟定时器和专业定时器的应用场景，以及如何通过sleep和usleep函数实现简单的定时任务。此外，文章还提供了一个测试程序实例，展示了如何在C语言中利用定时器进行任务调度。

使用定时器的目的无非是为了周期性的执行某一任务，或者是到了一个指定时间去执行某一个任务。要达到这一目的，一般有两个常见的比较有效的方法。一个是用linux内部的三个定时器，另一个是用sleep, usleep函数让进程睡眠一段时间，使用alarm定时发出一个信号，还有那就是用gettimeofday, difftime等自己来计算时间间隔，然后时间到了就执行某一任务，但是这种方法效率低，所以不常用。

alarm

alarm用在不需要经确定时的时候，返回之前剩余的秒数。

NAME
       alarm - set an alarm clock for delivery of a signal
SYNOPSIS
       #include <unistd.h>
       unsigned int alarm(unsigned int seconds);
DESCRIPTION
       alarm  arranges  for a SIGALRM signal to be delivered to the process in
       seconds seconds.
       If seconds is zero, no new alarm is scheduled.
       In any event any previously set alarm is cancelled.

测试程序：

1   cat timer.c
2  #include <stdio.h>
3  #include <unistd.h>
4  #include <sys/time.h>
5  #include <signal.h>
6   
7  void func()
8  {
9          printf("2 s reached.\n");
10  }
11   
12  int main()
13  {
14          signal(SIGALRM,func);
15          alarm(2);
16          while(1);
17          return 0;
18  }
19   
Linux内置的3个定时器

Linux为每个任务安排了3个内部定时器：

ITIMER_REAL：实时定时器，不管进程在何种模式下运行（甚至在进程被挂起时），它总在计数。定时到达，向进程发送SIGALRM信号。

ITIMER_VIRTUAL：这个不是实时定时器，当进程在用户模式（即程序执行时）计算进程执行的时间。定时到达后向该进程发送SIGVTALRM信号。 

ITIMER_PROF：进程在用户模式（即程序执行时）和核心模式（即进程调度用时）均计数。定时到达产生SIGPROF信号。ITIMER_PROF记录的时间比ITIMER_VIRTUAL多了进程调度所花的时间。

定时器在初始化是，被赋予一个初始值，随时间递减，递减至0后发出信号，同时恢复初始值。在任务中，我们可以一种或者全部三种定时器，但同一时刻同一类型的定时器只能使用一个。

 

用到的函数有：

#include <sys/time.h>
int getitimer(int which, struct itimerval *value);
int setitimer(int which, struct itimerval*newvalue, struct itimerval* oldvalue);
strcut timeval
{
long tv_sec; /*秒*/
long tv_usec; /*微秒*/
};
struct itimerval
{
struct timeval it_interval; /*时间间隔*/
struct timeval it_value;   /*当前时间计数*/
};

it_interval用来指定每隔多长时间执行任务， it_value用来保存当前时间离执行任务还有多长时间。比如说， 你指定it_interval为2秒(微秒为0)，开始的时候我们把it_value的时间也设定为2秒（微秒为0），当过了一秒， it_value就减少一个为1， 再过1秒，则it_value又减少1，变为0，这个时候发出信号（告诉用户时间到了，可以执行任务了），并且系统自动把it_value的时间重置为it_interval的值，即2秒，再重新计数。

为了帮助你理解这个问题，我们来看一个例子：

1  #include <stdio.h>
2  #include <signal.h>
3  #include <sys/time.h>
4   
5  /*
6  *******************************************************************************************************
7  ** Function name: main()
8  ** Descriptions : Demo for timer.
9  ** Input        : NONE
10  ** Output       : NONE
11  ** Created by   : Chenxibing
12  ** Created Date : 2005-12-29
13  **-----------------------------------------------------------------------------------------------------
14  ** Modified by  :
15  ** Modified Date:
16  **-----------------------------------------------------------------------------------------------------
17  *******************************************************************************************************
18  */
19  int limit = 10;
20  /* signal process */
21  void timeout_info(int signo)
22  {
23      if(limit == 0)
24      {
25          printf("Sorry, time limit reached.\n");
26          return;
27      }
28      printf("only %d senconds left.\n", limit--);
29  }
30   
31  /* init sigaction */
32  void init_sigaction(void)
33  {
34      struct sigaction act;
35   
36      act.sa_handler = timeout_info;
37      act.sa_flags   = 0;
38      sigemptyset(&act.sa_mask);
39      sigaction(SIGPROF, &act, NULL);
40  }
41   
42  /* init */
43  void init_time(void)
44  {
45      struct itimerval val;
46   
47      val.it_value.tv_sec = 1;
48      val.it_value.tv_usec = 0;
49      val.it_interval = val.it_value;
50      setitimer(ITIMER_PROF, &val, NULL);
51  }
52   
53   
54  int main(void)
55  {
56      init_sigaction();
57      init_time();
58      printf("You have only 10 seconds for thinking.\n");
59   
60      while(1);
61     return 0;
62  }
63   

对于ITIMER_VIRTUAL和ITIMER_PROF的使用方法类似，当你在setitimer里面设置的定时器为ITIMER_VIRTUAL的时候，你把sigaction里面的SIGALRM改为SIGVTALARM, 同理，ITIMER_PROF对应SIGPROF。

不过，你可能会注意到，当你用ITIMER_VIRTUAL和ITIMER_PROF的时候，你拿一个秒表，你会发现程序输出字符串的时间间隔会不止2秒，甚至5-6秒才会输出一个，至于为什么，自己好好琢磨一下^_^

sleep

下面我们来看看用sleep以及usleep怎么实现定时执行任务。

  1. #include <signal.h>
  2. #include <unistd.h>
  3. #include <string.h>
  4. #include <stdio.h>
  6. static char msg[] = "I received a msg.\n";
  7. int len;
  8. void show_msg(int signo)
  9. {
  10. write(STDERR_FILENO, msg, len);
  11. }
  12. int main()
  13. {
  14. struct sigaction act;
  15. union sigval tsval;
  17. act.sa_handler = show_msg;
  18. act.sa_flags = 0;
  19. sigemptyset(&act.sa_mask);
  20. sigaction(50, &act, NULL);
  22. len = strlen(msg);
  23. while ( 1 )
  24. {
  25. sleep(2); /*睡眠2秒*/
  26. /*向主进程发送信号，实际上是自己给自己发信号*/
  27. sigqueue(getpid(), 50, tsval);
  28. }
  29. return 0;
  30. }

看到了吧，这个要比上面的简单多了，而且你用秒表测一下，时间很准，指定2秒到了就给你输出一个字符串。所以，如果你只做一般的定时，到了时间去执行一个任务，这种方法是最简单的。

时间差

下面我们来看看，通过自己计算时间差的方法来定时：

 

  1. #include <signal.h>
  2. #include <unistd.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <time.h>
  7. static char msg[] = "I received a msg.\n";
  8. int len;
  9. static time_t lasttime;
  10. void show_msg(int signo)
  11. {
  12. write(STDERR_FILENO, msg, len);
  13. }
  14. int main()
  15. {
  16. struct sigaction act;
  17. union sigval tsval;
  19. act.sa_handler = show_msg;
  20. act.sa_flags = 0;
  21. sigemptyset(&act.sa_mask);
  22. sigaction(50, &act, NULL);
  24. len = strlen(msg);
  25. time(&lasttime);
  26. while ( 1 )
  27. {
  28. time_t nowtime;
  29. /*获取当前时间*/
  30. time(&nowtime);
  31. /*和上一次的时间做比较，如果大于等于2秒，则立刻发送信号*/
  32. if (nowtime - lasttime >= 2)
  33. {
  34. /*向主进程发送信号，实际上是自己给自己发信号*/
  35. sigqueue(getpid(), 50, tsval);
  36. lasttime = nowtime;
  37. }
  38. }
  39. return 0;
  40. }

这个和上面不同之处在于，是自己手工计算时间差的，如果你想更精确的计算时间差，你可以把 time 函数换成gettimeofday，这个可以精确到微妙。

上面介绍的几种定时方法各有千秋，在计时效率上、方法上和时间的精确度上也各有不同，采用哪种方法，就看你程序的需要。


----------------------------------------------------------------------------------------------------------------------------------------------------------------------


线程sleep


C/C++ code
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef WIN32
    #include <windows.h>
    #include <io.h>
    #include <process.h>
    #define  MYVOID             void
#else
    #include <unistd.h>
    #include <sys/time.h>
    #include <pthread.h>
    #define  CRITICAL_SECTION   pthread_mutex_t
    #define  _vsnprintf         vsnprintf
    #define  MYVOID             void *
#endif
//Log{
#define MAXLOGSIZE 20000000
#define ARRSIZE(x) (sizeof(x)/sizeof(x[0]))
#include <time.h>
#include <sys/timeb.h>
#include <stdarg.h>
char logfilename1[]="MyLog1.log";
char logfilename2[]="MyLog2.log";
char logstr[16000];
char datestr[16];
char timestr[16];
char mss[4];
CRITICAL_SECTION cs_log;
FILE *flog;
#ifdef WIN32
void Lock(CRITICAL_SECTION *l) {
    EnterCriticalSection(l);
}
void Unlock(CRITICAL_SECTION *l) {
    LeaveCriticalSection(l);
}
void sleep_ms(int ms) {
    Sleep(ms);
}
#else
void Lock(CRITICAL_SECTION *l) {
    pthread_mutex_lock(l);
}
void Unlock(CRITICAL_SECTION *l) {
    pthread_mutex_unlock(l);
}
void sleep_ms(int ms) {
    usleep(ms*1000);
}
#endif
void LogV(const char *pszFmt,va_list argp) {
    struct tm *now;
    struct timeb tb;


    if (NULL==pszFmt||0==pszFmt[0]) return;
    if (-1==_vsnprintf(logstr,ARRSIZE(logstr),pszFmt,argp)) logstr[ARRSIZE(logstr)-1]=0;
    ftime(&tb);
    now=localtime(&tb.time);
    sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);
    sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );
    sprintf(mss,"%03d",tb.millitm);
    printf("%s %s.%s %s",datestr,timestr,mss,logstr);
    flog=fopen(logfilename1,"a");
    if (NULL!=flog) {
        fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);
        if (ftell(flog)>MAXLOGSIZE) {
            fclose(flog);
            if (rename(logfilename1,logfilename2)) {
                remove(logfilename2);
                rename(logfilename1,logfilename2);
            }
            flog=fopen(logfilename1,"a");
            if (NULL==flog) return;
        }
        fclose(flog);
    }
}
void Log(const char *pszFmt,...) {
    va_list argp;

    Lock(&cs_log);
    va_start(argp,pszFmt);
    LogV(pszFmt,argp);
    va_end(argp);
    Unlock(&cs_log);
}
//Log}
int No_Loop=0;
MYVOID testThread(void *pcn) {
    int n,i;

    n=(int)pcn;
    i=0;
    while (1) {
        sleep_ms(1000);
        Log("in testThread %d:i==%ds\n",n,++i);
        if (i>=5) No_Loop=1;
    }
}
int main(int argc,char * argv[]) {
    int i;
#ifdef WIN32
    InitializeCriticalSection(&cs_log);
#else
    pthread_mutex_init(&cs_log,NULL);
    pthread_t threads[1];
    int threadsN;
    int rc;
#endif
    Log("=========BEGIN==================\n");
#ifdef WIN32
    _beginthread((void(__cdecl *)(void *))testThread,0,(void *)1);
#else
    threadsN=0;
    rc=pthread_create(&(threads[threadsN++]),NULL,testThread,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
#endif
    i=0;
    while (1) {
        sleep_ms(100);
        Log("in main:i==%d\n",++i);
        if (No_Loop==1) break;//
    }
    Log("=========END====================\n");
#ifdef WIN32
    DeleteCriticalSection(&cs_log);
#else
    pthread_mutex_destroy(&cs_log);
#endif
    return 0;
}
//2012-06-14 16:27:21.500 =========BEGIN==================
//2012-06-14 16:27:21.609 in main:i==1
//2012-06-14 16:27:21.718 in main:i==2
//2012-06-14 16:27:21.828 in main:i==3
//2012-06-14 16:27:21.937 in main:i==4
//2012-06-14 16:27:22.046 in main:i==5
//2012-06-14 16:27:22.156 in main:i==6
//2012-06-14 16:27:22.265 in main:i==7
//2012-06-14 16:27:22.375 in main:i==8
//2012-06-14 16:27:22.484 in main:i==9
//2012-06-14 16:27:22.500 in testThread 1:i==1s
//2012-06-14 16:27:22.593 in main:i==10
//2012-06-14 16:27:22.703 in main:i==11
//2012-06-14 16:27:22.812 in main:i==12
//2012-06-14 16:27:22.921 in main:i==13
//2012-06-14 16:27:23.031 in main:i==14
//2012-06-14 16:27:23.140 in main:i==15
//2012-06-14 16:27:23.250 in main:i==16
//2012-06-14 16:27:23.359 in main:i==17
//2012-06-14 16:27:23.468 in main:i==18
//2012-06-14 16:27:23.500 in testThread 1:i==2s
//2012-06-14 16:27:23.578 in main:i==19
//2012-06-14 16:27:23.687 in main:i==20
//2012-06-14 16:27:23.796 in main:i==21
//2012-06-14 16:27:23.906 in main:i==22
//2012-06-14 16:27:24.015 in main:i==23
//2012-06-14 16:27:24.125 in main:i==24
//2012-06-14 16:27:24.234 in main:i==25
//2012-06-14 16:27:24.343 in main:i==26
//2012-06-14 16:27:24.453 in main:i==27
//2012-06-14 16:27:24.500 in testThread 1:i==3s
//2012-06-14 16:27:24.562 in main:i==28
//2012-06-14 16:27:24.671 in main:i==29
//2012-06-14 16:27:24.781 in main:i==30
//2012-06-14 16:27:24.890 in main:i==31
//2012-06-14 16:27:25.000 in main:i==32
//2012-06-14 16:27:25.109 in main:i==33
//2012-06-14 16:27:25.218 in main:i==34
//2012-06-14 16:27:25.328 in main:i==35
//2012-06-14 16:27:25.437 in main:i==36
//2012-06-14 16:27:25.500 in testThread 1:i==4s
//2012-06-14 16:27:25.546 in main:i==37
//2012-06-14 16:27:25.656 in main:i==38
//2012-06-14 16:27:25.765 in main:i==39
//2012-06-14 16:27:25.875 in main:i==40
//2012-06-14 16:27:25.984 in main:i==41
//2012-06-14 16:27:26.093 in main:i==42
//2012-06-14 16:27:26.203 in main:i==43
//2012-06-14 16:27:26.312 in main:i==44
//2012-06-14 16:27:26.421 in main:i==45
//2012-06-14 16:27:26.500 in testThread 1:i==5s
//2012-06-14 16:27:26.531 in main:i==46
//2012-06-14 16:27:26.531 =========END====================
 


    long458
    关注
    Linux 定时器：基本原理与使用指南
    小灰灰的博客
    07-15 422
    Linux定时器是实现时间相关任务的重要工具。无论是内核定时器还是POSIX定时器，它们都提供了灵活且强大的机制来管理时间和执行任务。通过本文的介绍，你应该对Linux定时器的基本原理、类型以及如何使用它们有了更深入的了解。希望这些知识能帮助你在实际开发中更好地利用定时器。
    Linux定时器及开发实战
    l_z_y_000的博客
    02-07 639
    Linux定时器及开发实战；Linux定时器及舵机开发实战
    Linux定时器的使用
    weixin_34393428的博客
    08-05 216
    Linux定时器的使用 Posted on 2010-03-20 17:40 feisky 阅读(1073) 评论(0) 编辑 收藏 使用定时器的目的无非是为了周期性的执行某一任务，或者是到了一个指定时间去执行某一个任务。要达到这一目的，一般有两个常见的比较有效的方法。一个是用linux内部的三个定时器，另一个是用sleep, usleep函数让进程睡眠一段...
    linux中定时器的使用
    最后一个bug的博客
    08-23 1071
    这里的定时器处理函数的执行是在主线程中，而不是在中断上下文中。因此，如果在定时器处理函数中执行耗时操作，会影响主线程的执行和响应性能。如果需要在实时系统中处理严格的时间要求，可以考虑使用实时定时器或者在定时器处理函数中进行简单的操作，然后将复杂的处理逻辑放到其他线程中执行。这意味着定时器的计时是基于实际的墙钟时间，可以用于实现各种时间相关的操作，如任务调度、定时任务等。在上述示例中，定时器初始延迟时间为5秒，定时器触发间隔为2秒。不是在中断中处理的，而是在主线程的上下文中执行的。，用于在定时器到期时触发。
    Linux 定时器使用
    one goto one 的博客
    07-05 1994
    Linux 下可以使用 alarm 函数或 setitimer 函数设置一个定时器。alarm 的定时器是以 秒计时的，setitime 的定时器可以精确到 微秒alarm 可以在进程中设置一个定时器，当定时器指定的时间到时，它向进程发送SIGALRM信号。可以设置忽略或者不捕获此信号，如果采用默认方式其动作是终止调用该alarm函数的进程。 seconds:指定秒数 成功：如果调用此alarm() 前，进程已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0 失败：-1示例： 二、setitim
    Linux 定时器的使用
    那块海绵的博客
    11-30 406
    Linux 定时器的使用有很多方法，常用的两种方式： 1.alarm 2.setitimer 一、alarm 1.函数介绍 signal（） 函数原型 ： void (*signal(int signum,void(* handler)(int)))(int); 　　 或者：typedef void(*sig_t) ( int ); 　　sig_t signal(int s
    linux 定时器的使用
    wanyongtai的博客
    09-13 344
    方法一rtc是linux系统中的一个时间设备，可以open打开，通过ioctl设置频率，然后就可以进行循环read操作，每次read的耗时是(1/频率 单位：秒)。精度较高，每10秒误差1ms#include <sys/ioctl.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <linux/rt
    linux定时器crontab的使用教程
    09-15
    Linux定时器crontab是Linux系统中用于自动化任务调度的强大工具，它允许用户根据预定义的时间间隔安排任务的执行。这篇教程将详细介绍如何使用crontab进行定时任务的设置。 首先，crontab命令用于管理和编辑用户的...
    Linux定时器与时间轮 实现网络连接超时关闭
    gma999的博客
    07-26 1388
    Linux定时器、时间轮、回调函数三者实现超时连接的关闭，从而实现服务器及时释放超时连接，提高服务器性能
    基于Linux 定时器的封装
    最新发布
    08-18
    本资源对linux常用的定时器进行了一定的封装并命名为rapaidx项目，包括rapaidx_timer_create（定时器生成）、rapaidx_timer_start（启动定时器）、rapaidx_timer_stop（停止定时器）、rapaidx_timer_restart（重启...
    linux定时器使用
    qq_45392866的博客
    07-04 692
    linux下编程POSIX定时器POSIX创建、初始化以及删除一个定时器的行为分为三个不同的函数：timer_create()、timer_settime()以及timer_delete()新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出
    Linux 定时器
    05-09 8803
    时间间隔定时器interval timer(时间间隔定时器)系统调用自从被POSIX标准化后，首次出现于4.2BSD，能够提供比alarm()还多的控制： #include int getitimer(int which, struct itimerval *value);int setitimer(int which, const struct itimerval *valu
    Linux下的定时器
    hfw_1987的专栏
    07-31 2780
    简介这篇文章主要记录我在试图解决如何尽可能精确地在某个特定的时间间隔执行某项具体任务时的思路历程，并在后期对相关的API进行的归纳和总结，以备参考。问题引出很多时候，我们会有类似“每隔多长时间执行某项任务”的需求，乍看这个问题并不难解决，实则并不容易，有很多隐含条件需要考虑，诸如：时间精度是多少？时间是否允许出现偏差，允许的偏差是多少，偏差之后如何处理？系统的负载如何？这个程序允许
    Linux-定时器
    xzzxwmsl的博客
    03-30 1301
    文章目录socket选项SO_RCVTIMEO和SO_SNDTIMEOexample，connect超时SIGALRM基于升序链表的定时器 定时是指一段时间后触发某段代码的机制，Linux提供了以下三种定时方法： socket选项SO_RCVTIMEO和SO_SNDTIMEO SIGALRM信号 I/O复用系统调用的超时参数 socket选项SO_RCVTIMEO和SO_SNDTIMEO 分别用来设置socket接收数据超时时间和发送数据超时时间，所以用于与socket数据收发有关的系统调用，如send
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

    当前余额3.43元 前往充值 >
    需支付：10.00元
    成就一亿技术人!
    领取后你会自动成为博主和红包主的粉丝 规则
    hope_wisdom
    发出的红包
    实付元
    使用余额支付
    点击重新获取
    扫码支付
    钱包余额 0

    抵扣说明：

    1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
    2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

    余额充值