2. 程式人生 > >關於Linux的應用層定時器

關於Linux的應用層定時器

阿新 • • 發佈：2019-02-17

　　使用定時器的目的無非是為了週期性的執行某一任務，或者是到了一個指定時間去執行某一個任務。要達到這一目的，一般有兩個常見的比較有效的方法。一個是用 Linux 內部的三個定時器；另一個是用 sleep 或 usleep 函式讓程序睡眠一段時間；其實，還有一個方法，那就是用 gettimeofday、difftime 等自己來計算時間間隔，然後時間到了就執行某一任務，但是這種方法效率低，所以不常用。

1、alarm
　　如果不要求很精確的話，用 alarm() 和 signal() 就夠了

unsigned int alarm(unsigned int seconds)

　　專門為SIGALRM訊號而設，在指定的時間seconds秒後，將向程序本身傳送SIGALRM訊號，又稱為鬧鐘時間。程序呼叫alarm後，任何以前的alarm()呼叫都將無效。如果引數seconds為零，那麼程序內將不再包含任何鬧鐘時間。如果呼叫alarm（）前，程序中已經設定了鬧鐘時間，則返回上一個鬧鐘時間的剩餘時間，否則返回0。
示例：

#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();
}

2、setitimer

int setitimer(int which, const struct
 
 itimerval *value, struct itimerval *ovalue));
int getitimer(int which, struct itimerval *value);

strcut timeval
{
   long tv_sec; /*秒*/
   long tv_usec; /*微秒*/
};

struct itimerval
{
   struct timeval it_interval; /*時間間隔*/
   struct timeval it_value; /*當前時間計數*/
};

setitimer() 比 alarm() 功能強大，支援3種類型的定時器：

① ITIMER_REAL

：給一個指定的時間間隔，按照實際的時間來減少這個計數，當時間間隔為0的時候發出SIGALRM訊號。
② ITIMER_VIRTUAL：給定一個時間間隔，當程序執行的時候才減少計數，時間間隔為0的時候發出SIGVTALRM訊號。
③ ITIMER_PROF：給定一個時間間隔，當程序執行或者是系統為程序排程的時候，減少計數，時間到了，發出SIGPROF訊號。

　　setitimer() 第一個引數 which 指定定時器型別（上面三種之一）；第二個引數是結構 itimerval 的一個例項；第三個引數可不做處理。
　　下面是關於setitimer呼叫的一個簡單示範，在該例子中，每隔一秒發出一個SIGALRM，每隔0.5秒發出一個SIGVTALRM訊號：：

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

int sec;

void sigroutine(int signo){
   switch (signo){
   case SIGALRM:
       printf("Catch a signal -- SIGALRM \n");
       signal(SIGALRM, sigroutine);
       break;
   case SIGVTALRM:
       printf("Catch a signal -- SIGVTALRM \n");
       signal(SIGVTALRM, sigroutine);
       break;
   }
   return;
}

int main()
{
   struct itimerval value, ovalue, value2;

   sec = 5;
   printf("process id is %d ", getpid());
   signal(SIGALRM, sigroutine);
   signal(SIGVTALRM, sigroutine);
   value.it_value.tv_sec = 1;
   value.it_value.tv_usec = 0;
   value.it_interval.tv_sec = 1;
   value.it_interval.tv_usec = 0;
   setitimer(ITIMER_REAL, &value, &ovalue);
   value2.it_value.tv_sec = 0;
   value2.it_value.tv_usec = 500000;
   value2.it_interval.tv_sec = 0;
   value2.it_interval.tv_usec = 500000;
   setitimer(ITIMER_VIRTUAL, &value2, &ovalue);
   for(;;);
}

　　該例子的執行結果如下：

localhost:~$ ./timer_test
process id is 579
Catch a signal – SIGVTALRM
Catch a signal – SIGALRM
Catch a signal – SIGVTALRM
Catch a signal – SIGVTALRM
Catch a signal – SIGALRM
Catch a signal –GVTALRM

　　注意：Linux訊號機制基本上是從Unix系統中繼承過來的。早期Unix系統中的訊號機制比較簡單和原始，後來在實踐中暴露出一些問題，因此，把那些建立在早期機制上的訊號叫做”不可靠訊號”，訊號值小於SIGRTMIN(Red hat 7.2中，SIGRTMIN=32，SIGRTMAX=63)的訊號都是不可靠訊號。這就是”不可靠訊號”的來源。它的主要問題是：程序每次處理訊號後，就將對訊號的響應設定為預設動作。在某些情況下，將導致對訊號的錯誤處理；因此，使用者如果不希望這樣的操作，那麼就要在訊號處理函式結尾再一次呼叫 signal()，重新安裝該訊號。

3、用 sleep 以及 usleep 實現定時執行任務

#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

static char msg[] = "I received a msg.\n";
int len;

void show_msg(int signo)
{
    write(STDERR_FILENO, msg, len);
}

int main()
{
    struct sigaction act;
    union sigval tsval;
    act.sa_handler = show_msg;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(50, &act, NULL);
    len = strlen(msg);
    while ( 1 )
    {
        sleep(2); /*睡眠2秒*/
        /*向主程序傳送訊號，實際上是自己給自己發訊號*/
        sigqueue(getpid(), 50, tsval);
    }
    return 0;
}

　　看到了吧，這個要比上面的簡單多了，而且你用秒錶測一下，時間很準，指定2秒到了就給你輸出一個字串。所以，如果你只做一般的定時，到了時間去執行一個任務，這種方法是最簡單的。

4、通過自己計算時間差的方法來定時

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

static char msg[] = "I received a msg.\n";
int len;
static time_t lasttime;

void show_msg(int signo)
{
    write(STDERR_FILENO, msg, len);
}

int main()
{
    struct sigaction act;
    union sigval tsval;
    act.sa_handler = show_msg;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(50, &act, NULL);
    len = strlen(msg);
    time(&lasttime);
    while ( 1 )
    {
        time_t nowtime;
        /*獲取當前時間*/
        time(&nowtime);
        /*和上一次的時間做比較，如果大於等於2秒，則立刻傳送訊號*/
        if (nowtime - lasttime >= 2)
        {
            /*向主程序傳送訊號，實際上是自己給自己發訊號*/
            sigqueue(getpid(), 50, tsval);
            lasttime = nowtime;
        }
    }
    return 0;
}

　　這個和上面不同之處在於，是自己手工計算時間差的，如果你想更精確的計算時間差，你可以把 time 函式換成 gettimeofday，這個可以精確到微妙。

5、使用 select 來提供精確定時和休眠

 int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

　　n 指監視的檔案描述符範圍，通常設為所要select的fd＋1；readfds，writefds 和 exceptfds分別是讀，寫和異常檔案描述符集；timeout 為超時時間。

　　可能用到的關於檔案描述符集操作的巨集有：

    FD_CLR(int fd, fd_set *set);   // 清除fd
    FD_ISSET(int fd, fd_set *set); // 測試fd是否設定
    FD_SET(int fd, fd_set *set);   //設定fd
    FD_ZERO(fd_set *set);          //清空描述符集

　　我們此時用不到這些巨集，因為我們並不關心檔案描述符的狀態，我們關心的是select超時。所以我們需要把 readfds，writefds 和 exceptfds 都設為 NULL，只指定 timeout 時間就行了。至於 n 我們可以不關心，所以你可以把它設為任何非負值。實現程式碼如下：

 int msSleep(long ms) 
 {
    struct timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = ms;

    return select(0, NULL, NULL, NULL, &tv);
 }

　　怎麼樣，是不是很簡單？ setitimer 和 select 都能實現程序的精確休眠，這裡給出了一個簡單的基於 select 的實現。我不推薦使用 setitimer，因為 Linux 系統提供的 timer 有限（每個程序至多能設3個不同型別的 timer），而且 setitimer 實現起來沒有 select 簡單。

6、高精度硬體中斷定時器 hrtimer

　　需要在 kernel 中開啟 “high resolution Timer support”，驅動程式中 hrtimer 的初始化如下：

hrtimer_init(&m_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_PINNED);
m_timer.function = vibrator_timer_func;
hrtimer_start(&m_timer, ktime_set(0, 62500), HRTIMER_MODE_REL_PINNED);

定時函式 vibrator_timer_func 如下：

static enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer)
{
  gpio_set_value(gpio_test, 1);
  gpio_set_value(gpio_test, 0);
  hrtimer_forward_now(&m_timer,ktime_set(0, 62500));
  return HRTIMER_RESTART;
}

　　其中 gpio_test 為輸出引腳，為了方便輸出檢視。但是用示波器檢視引腳波形時，發現雖然設定的週期為62.5us，但是輸出總是為72us左右，而且偶爾會有兩個波形靠的很近（也就是說週期突然變為10us以下）。我將週期設到40us的話，就會出現72us和10us經常交替出現，無法實現精確的40us的波形，如果設定到100us時，則波形就是100us了，而且貌似沒有看到有10us以下的週期出現。

7、高精度定時器 posix_timer

　　最強大的定時器介面來自POSIX時鐘系列，其建立、初始化以及刪除一個定時器的行動被分為三個不同的函式：timer_create()(建立定時器)、timer_settime()(初始化定時器)以及 timer_delete()(銷燬它)。

建立一個定時器：

int timer_create(clockid_t clock_id, struct sigevent *evp, timer_t *timerid)

　　程序可以通過呼叫 timer_create() 建立特定的定時器，定時器是每個程序自己的，不是在 fork 時繼承的。clock_id 說明定時器是基於哪個時鐘的，*timerid 裝載的是被建立的定時器的 ID。該函式建立了定時器，並將他的 ID 放入timerid指向的位置中。引數evp指定了定時器到期要產生的非同步通知。如果evp為 NULL，那麼定時器到期會產生預設的訊號，對 CLOCK_REALTIMER來說，預設訊號就是SIGALRM。如果要產生除預設訊號之外的其它訊號，程式必須將 evp->sigev_signo設定為期望的訊號碼。struct sigevent 結構中的成員 evp->sigev_notify說明了定時器到期時應該採取的行動。通常，這個成員的值為SIGEV_SIGNAL，這個值說明在定時器到期時，會產生一個訊號。程式可以將成員 evp->sigev_notify設為SIGEV_NONE來防止定時器到期時產生訊號。

　　如果幾個定時器產生了同一個訊號，處理程式可以用 evp->sigev_value來區分是哪個定時器產生了訊號。要實現這種功能，程式必須在為訊號安裝處理程式時，使用struct sigaction的成員sa_flags中的標誌符SA_SIGINFO。

clock_id取值為以下：
CLOCK_REALTIME :Systemwide realtime clock.
CLOCK_MONOTONIC:Represents monotonic time. Cannot be set.
CLOCK_PROCESS_CPUTIME_ID :High resolution per-process timer.
CLOCK_THREAD_CPUTIME_ID :Thread-specific timer.
CLOCK_REALTIME_HR :High resolution version of CLOCK_REALTIME.
CLOCK_MONOTONIC_HR :High resolution version of CLOCK_MONOTONIC.

struct sigevent
{
int sigev_notify; //notification type
int sigev_signo; //signal number
union sigval   sigev_value; //signal value
void (*sigev_notify_function)(union sigval);
pthread_attr_t *sigev_notify_attributes;
}
union sigval
{
int sival_int; //integer value
void *sival_ptr; //pointer value
}

通過將evp->sigev_notify設定為如下值來定製定時器到期後的行為：
SIGEV_NONE：什麼都不做，只提供通過timer_gettime和timer_getoverrun查詢超時資訊。
SIGEV_SIGNAL: 當定時器到期，核心會將sigev_signo所指定的訊號傳送給程序。在訊號處理程式中，si_value會被設定會sigev_value。
SIGEV_THREAD: 當定時器到期，核心會(在此程序內)以sigev_notification_attributes為執行緒屬性建立一個執行緒，並且讓它執行sigev_notify_function，傳入sigev_value作為為一個引數。

啟動一個定時器：
timer_create()所建立的定時器並未啟動。要將它關聯到一個到期時間以及啟動時鐘週期，可以使用timer_settime()。

int timer_settime(timer_t timerid, int flags, const struct itimerspec *value, struct itimerspect *ovalue);

struct itimespec{
    struct timespec it_interval; 
    struct timespec it_value;   
};

　　如同settimer()，it_value用於指定當前的定時器到期時間。當定時器到期，it_value的值會被更新成it_interval 的值。如果it_interval的值為0，則定時器不是一個時間間隔定時器，一旦it_value到期就會回到未啟動狀態。timespec的結構提供了納秒級解析度：

struct timespec{
    time_t tv_sec;
    long tv_nsec;  
};

　　如果flags的值為TIMER_ABSTIME，則value所指定的時間值會被解讀成絕對值(此值的預設的解讀方式為相對於當前的時間)。這個經修改的行為可避免取得當前時間、計算“該時間”與“所期望的未來時間”的相對差額以及啟動定時器期間造成競爭條件。
　　如果ovalue的值不是NULL，則之前的定時器到期時間會被存入其所提供的itimerspec。如果定時器之前處在未啟動狀態，則此結構的成員全都會被設定成0。

獲得一個活動定時器的剩餘時間：

int timer_gettime(timer_t timerid,struct itimerspec *value);

取得一個定時器的超限執行次數：
　　有可能一個定時器到期了，而同一定時器上一次到期時產生的訊號還處於掛起狀態。在這種情況下，其中的一個訊號可能會丟失。這就是定時器超限。程式可以通過呼叫timer_getoverrun來確定一個特定的定時器出現這種超限的次數。定時器超限只能發生在同一個定時器產生的訊號上。由多個定時器，甚至是那些使用相同的時鐘和訊號的定時器，所產生的訊號都會排隊而不會丟失。

int timer_getoverrun(timer_t timerid);

　　執行成功時，timer_getoverrun()會返回定時器初次到期與通知程序(例如通過訊號)定時器已到期之間額外發生的定時器到期次數。舉例來說，在我們之前的例子中，一個1ms的定時器運行了10ms，則此呼叫會返回9。如果超限執行的次數等於或大於DELAYTIMER_MAX，則此呼叫會返回DELAYTIMER_MAX。
　　執行失敗時，此函式會返回-1並將errno設定會EINVAL，這個唯一的錯誤情況代表timerid指定了無效的定時器。

刪除一個定時器：

int timer_delete (timer_t timerid);

　　一次成功的timer_delete()呼叫會銷燬關聯到timerid的定時器並且返回0。執行失敗時，此呼叫會返回-1並將errno設定會 EINVAL，這個唯一的錯誤情況代表timerid不是一個有效的定時器。

例1：

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;
 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);
}

例2：

void  handle(union sigval v)
{
 time_t t;
 char p[32];
 time(&t);
 strftime(p, sizeof(p), "%T", localtime(&t));
 printf("%s thread %lu, val = %d, signal captured.\n", p, pthread_self(), v.sival_int);
 return;
}

int main()
{
 struct sigevent evp;
 struct itimerspec ts;
 timer_t timer;
 int ret;
 memset   (&evp,   0,   sizeof   (evp));
 evp.sigev_value.sival_ptr = &timer;
 evp.sigev_notify = SIGEV_THREAD;
 evp.sigev_notify_function = handle;
 evp.sigev_value.sival_int = 3;   //作為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, TIMER_ABSTIME, &ts, NULL);
 if( ret )
  perror("timer_settime");
 while(1);
}

相關推薦

關於Linux的應用層定時器

　　使用定時器的目的無非是為了週期性的執行某一任務，或者是到了一個指定時間去執行某一個任務。要達到這一目的，一般有兩個常見的比較有效的方法。一個是用 Linux 內部的三個定時器；另一個是用 sleep 或 usleep 函式讓程序睡眠一段時間；其實，還有一個方

Linux應用層的定時器Timer

       通過第一個引數which來指定要使用哪一種Timer（ITIMER_REAL、ITIMER_VIRTUAL、ITIMER_PROF）。settimer函式是用來設定對應的Timer的觸發時間是多少，而gettimer函式是用來獲取上一次Timer設定的時間。設定的時間是一個結構體struct

Linux驅動之定時器在按鍵去抖中的應用

arc div 測試 完整 esc arm 是否 reg blog 機械按鍵在按下的過程中會出現抖動的情況，如下圖，這樣就會導致本來按下一次按鍵的過程會出現多次中斷，導致判斷出錯。在按鍵驅動程序中我們可以這麽做： 在按鍵驅動程序中我們可以這麽做來取消按鍵抖動的影響：當出現

Linux 高精度定時器hrtimers簡單介紹和應用場景

hrtimer:high-resolution kernel timers:   hrtimers的誕生是由於核心開發者在使用過程中發現，原始的定時器kernel/timers.c,已經可以滿足所有場景的，但是在實際的大量測試中發現還是無法滿足所有場景，所以hrtime

LINUX使用一個定時器實現設置任意數量定時器

ftw rup () int stdlib.h val span 時鐘 sof 本例子參考 Don Libes的Title: Implementing Software Timers例子改寫 為什麽需要這個功能，因為大多數計算機軟件時鐘系統通常只能有一個時鐘觸發一次

linux時間和定時器zz

一段時間 納秒 target 程序 set 不能 ive thread 微秒 https://www.cnblogs.com/cobbliu/p/3627061.html Linux 的計時函數，用於獲得當前時間： time(2) / time_t （秒） ftime(3

荔枝派 V3S Linux 應用層 IIC 使用OLED

ddr 開始 出現 驅動程序 line 但是 IE HR 手冊 1.開始 　　我想在荔枝派上驅動oled屏，但是在內核中寫驅動對我來說肯定是非常麻煩的，所以我退而求其次，想在應用層中操作通用i2c接口來實現oled的驅動程序。 我買的OLED是中景園經典款，四針IIC接口o

Linux應用層直接操作GPIO

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

redis 在業務層面的應用之定時器

    前幾天出去面試，大家都喜歡聊redis，一個是底層資料結構的實現，一個是在業務層的使用，這裡就結合一些簡單的python程式碼，講下怎樣用redis 做應用層面的定時器。     首先，當大批量任務做超時管理，就會涉及到如何實現定時器，使系統開銷最

Linux 的 crontab 定時器 任務排程

原創轉載自海牛部落－青牛,http://hainiubl.com/topics/188 1.linux的crontab cron不停地檢查所有配置的任務在當前是否應該執行，任務執行的最小時間間隔是1分鐘，也就是說任務最頻繁只能每分鐘執行一次。 (1).crontab命令選項 cronta

linux中的定時器

定時器 網路程式經常需要處理的一類事件是定時器事件，伺服器程式通常管理著眾多定時事件，因此有效低組織這些定時事件，使之能在預期的時間點被觸發而不影響伺服器的主要邏輯，對於伺服器的效能有著至關重要的影響。為此，將每個定時事件分別封裝成定時器，並使用某種容器類資料結構，比如連結

linux應用層下用C呼叫音訊驅動

static void audio_pause(void) {     int err;     if (alsa_can_pause) {         if ((err = snd_pcm_pause(alsa_handler, 1)) < 0)        

手把手教你寫Linux裝置驅動---定時器(一)(基於友善之臂4412開發板)

這個專題我們來說下Linux中的定時器。在Linux核心中，有這樣的一個定時器，叫做核心定時器，核心定時器用於控制某個函式，也就是定時器將要處理的函式在未來的某個特定的時間內執行。核心定時器註冊的處理函

Linux C/C++定時器的實現原理和使用方法

定時器的實現原理 定時器的實現依賴的是CPU時鐘中斷，時鐘中斷的精度就決定定時器精度的極限。一個時鐘中斷源如何實現多個定時器呢？對於核心，簡單來說就是用特定的資料結構管理眾多的定時器，在時鐘中斷處理中判斷哪些定時器超時，然後執行超時處理動作。而使用者空間程式不

Linux應用層讀寫i2c從裝置（eeprom）

/***************************************************************************** i2c讀函式，引數1：從裝置地址，引數2：暫存器地址，引數3：讀取資料緩衝區，引數4：讀取資料大小

應用層管理器詳細介紹

/** * 獲取應用層視窗管理器 * @param mContext * @return */ public static WindowManager getWindowManager(Context mContext) { WindowMana

linux應用層獲取滑鼠座標

補充：在這個函式中要開啟一個滑鼠裝置，但是在嵌入式的檔案系統中沒有這個裝置節點，滑鼠裝置的主裝置號和次裝置號有是如何確定的呢？在  linux 系統中，滑鼠和鍵盤的裝置號都是固定的，可以在 PC 上檢視，再在嵌入式的檔案系統中自己建立。[email protected]:/tmp$ ls -l /

Linux核心系統定時器TIMER實現過程分析

Linux系統定時器，在核心中扮演著重要角色。核心的許多重要實現如任務排程，工作佇列等均以系統定時器關係密切。系統定時器能以可程式設計的頻率中斷處理，這一中斷叫做軟中斷。此頻率即為每秒的定時器節拍數HZ。HZ的越大，說明定時器節拍越小，執行緒排程的準確性會越高。但HZ設得

[轉]淺析 Linux 中的時間程式設計和實現原理，第 1 部分: Linux 應用層的時間程式設計

引子 我們都生活在時間中，但卻無法去思考它。什麼是時間呢？似乎這是一個永遠也不能被回答的問題。然而作為一個程式設計師，在工作中，總有那麼幾次我必須思考什麼是時間。比如，需要知道一段程式碼運行了多久；要在 log 檔案中記錄事件發生時的時間戳；再比如需要一個定時器以便能夠定期做某些計算機操作。我發現，在計算機

嵌入式linux的開發流程以及linux應用層內容

嵌入式linux開發流程：1.搭建前期的開發環境，例如搭建linux主機環境，交叉編譯器的安裝，還有一些常用的開發輔助軟體如source insight等等。2.學習對硬體的直接操作，這裡和微控制器操作類似，我們需要檢視原理圖還有資料手冊對相應的暫存器進行操作，實現功能。這裡