系統中的一個模組需要頻繁的獲取系統時間，使用linux中內建的函式開銷過大，因為需要的精度不是很高（毫秒級），索性用signal函式配合setitimer實現了個簡易的全域性時鐘。

但是後來發現，SIGALRM的中斷訊號回終止sleep，因為sleep就是用SIGALRM訊號量實現的，得另想方案。

這個替代方案就是POSIX中內建的定時器：timer_create()(建立)、timer_settime()(初始化)以及timer_delete(銷燬)，將自己的時間訊號處理函式用timer_create註冊為SIGUSR2，這樣就不會中斷sleep了。

POSIX定時器:timer_settime()

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

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

1. struct itimespec{ 
2.     struct timespec it_interval;  
3.     struct
   timespec it_value;  
4. };  

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

程序可以通過呼叫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.

1. struct sigevent 
2. { 
3.     int sigev_notify; //notification type
4.     int sigev_signo; //signal number
5.     union sigval   sigev_value; //signal valu
6.     void (*sigev_notify_function)(union sigval) 
7.     pthread_attr_t *sigev_notify_attributes 
8. } 
9. union sigval 
10. { 
11.     int sival_int; //integer valu
12.     void *sival_ptr; //pointer value
13. } 

struct sigevent

{
    int sigev_notify; //notification type
    int sigev_signo; //signal number
    union sigval   sigev_value; //signal valu
    void (*sigev_notify_function)(union sigval)
    pthread_attr_t *sigev_notify_attributes
}

union sigval

{

    int sival_int; //integer valu
    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);

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

1. struct timespec{ 
2.     time_t tv_sec; 
3.     long tv_nsec;  
4. }; 

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：

1. void handle() 
2. { 
3.     time_t t; 
4.     char p[32]; 
5.     time(&t); 
6.     strftime(p, sizeof(p), "%T", localtime(&t)); 
7.     printf("time is %s\n", p); 
8. } 
9. int main() 
10. { 
11.     struct sigevent evp; 
12.     struct itimerspec ts; 
13.     timer_t timer; 
14.     int ret; 
15.     evp.sigev_value.sival_ptr = &timer; 
16.     evp.sigev_notify = SIGEV_SIGNAL; 
17.     evp.sigev_signo = SIGUSR1; 
18.     signal(SIGUSR1, handle); 
19.     ret = timer_create(CLOCK_REALTIME, &evp, &timer); 
20.     if( ret ) 
21.         perror("timer_create"); 
22.     ts.it_interval.tv_sec = 1; 
23.     ts.it_interval.tv_nsec = 0; 
24.     ts.it_value.tv_sec = 3; 
25.     ts.it_value.tv_nsec = 0; 
26.     ret = timer_settime(timer, 0, &ts, NULL); 
27.     if( ret ) 
28.     perror("timer_settime"); 
29.     while(1); 
30. } 

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：

1. void handle(union sigval v) 
2. { 
3.     time_t t; 
4.     char p[32]; 
5.     time(&t); 
6.     strftime(p, sizeof(p), "%T", localtime(&t)); 
7.     printf("%s thread %lu, val = %d, signal captured.\n", p, pthread_self(), v.sival_int); 
8.     return; 
9. } 
10. int main() 
11. { 
12.     struct sigevent evp; 
13.     struct itimerspec ts; 
14.     timer_t timer; 
15.     int ret; 
16.     memset (&evp, 0, sizeof (evp)); 
17.     evp.sigev_value.sival_ptr = &timer; 
18.     evp.sigev_notify = SIGEV_THREAD; 
19.     evp.sigev_notify_function = handle; 
20.     evp.sigev_value.sival_int = 3; //作為handle()的引數
21.     ret = timer_create(CLOCK_REALTIME, &evp, &timer); 
22.     if( ret) 
23.         perror("timer_create"); 
24.     ts.it_interval.tv_sec = 1; 
25.     ts.it_interval.tv_nsec = 0; 
26.     ts.it_value.tv_sec = 3; 
27.     ts.it_value.tv_nsec = 0; 
28.     ret = timer_settime(timer, TIMER_ABSTIME, &ts, NULL); 
29.     if( ret ) 
30.         perror("timer_settime"); 
31.     while(1); 
32. } 

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