Sommario di diversi metodi per implementare il timer Timer sotto linux

L'applicazione del timer Timer è molto ampia, sotto Linux, ci sono diversi metodi:

1, utilizzare sleep() e usleep()

Dove la precisione di sleep è di 1 secondo, quella di usleep è di 1 microsecondo, il codice specifico non viene scritto. Questo metodo ha svantaggi piuttosto evidenti, nel sistema Linux, le funzioni sleep non possono garantire la precisione, specialmente quando il carico del sistema è molto alto, sleep di solito avrà il fenomeno di timeout.

2, utilizzare il segnale SIGALRM + alarm()

La precisione di questo metodo può raggiungere 1 secondo, utilizzando il meccanismo dei segnali del sistema *nix, prima di registrare la funzione di gestione del segnale SIGALRM, chiamare alarm(), impostare la lunghezza del timer, il codice è come segue:

#include <stdio.h>
#include <signal.h>
void timer(int sig)
{
    if(SIGALRM == sig)
    {
        printf("timer\n");
        alarm(1);    //continuiamo a impostare il timer
    }
    return ;
}
int main()
{
    signal(SIGALRM, timer); //collega il segnale e la funzione
    alarm(1);    //attiva il timer
    getchar();
    return 0;
}

Il metodo di allarme è molto buono, ma non può avere una precisione inferiore a 1 secondo.

3, utilizza il meccanismo RTC

Il meccanismo RTC utilizza il meccanismo Real Time Clock fornito dal hardware del sistema, leggendo il RTC hardware /dev/rtc, impostando la frequenza RTC tramite ioctl(), il codice è il seguente:

#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);
    }
    /* Imposta la frequenza a 4Hz */
    if(ioctl(fd, RTC_IRQP_SET, 1) < 0)
    {
        perror("ioctl(RTC_IRQP_SET)");
        close(fd);
        exit(errno);
    }
    /* Abilita gli interrupt periodici */
    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("timer\n");
    }
    /* Disabilita gli interrupt periodici */
    ioctl(fd, RTC_PIE_OFF, 0);
    close(fd);
    return 0;
}

Questo metodo è molto conveniente, utilizza l'RTC fornito dal hardware del sistema, la precisione è regolabile e molto alta.

4, utilizzare select()

Questo metodo è stato trovato nel libro APUE, un metodo piuttosto raro, che utilizza select() per impostare il timer; il principio utilizza il quinto parametro del metodo select(), il primo parametro è impostato a 0, i tre set di descrittori di file sono impostati a NULL, il quinto parametro è la struttura di tempo, il codice è come segue:

#include <sys/time.h>
#include <sys/select.h>
#include <time.h>
#include <stdio.h>
/*seconds: i secondi; mseconds: i microsecondi*/
void setTimer(int seconds, int mseconds)
{
    struct timeval temp;
    temp.tv_sec = seconds;
    temp.tv_usec = mseconds;
    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;
}

Questo metodo può raggiungere la precisione a livello di microsecondo, ci sono molti timer multithreading basati su select() su Internet, il che indica che la stabilità di select() è ancora molto buona.

Sommario:Se le richieste del sistema sono relativamente basse, si può considerare l'uso di un semplice sleep(), dopo tutto, una riga di codice può risolvere il problema; se il sistema richiede una precisione più alta, allora si può considerare il meccanismo RTC e il meccanismo select().

Questo è tutto il contenuto che l'autore ha messo a disposizione per i metodi di implementazione del timer Timer sotto Linux, speriamo che riceviate molta supporto e incoraggiamento da Guida Shouting~