Resumo de várias maneiras de implementar o temporizador Timer no Linux

O aplicativo do temporizador Timer é muito amplo, no Linux, há várias maneiras:

1，使用sleep()和usleep()

onde a precisão do sleep é1segundo, a precisão do usleep é1Sutil, não vou escrever o código específico. A desvantagem deste método é bastante evidente, no sistema Linux, as funções sleep não garantem a precisão, especialmente quando a carga do sistema é grande, geralmente haverá fenômeno de timeout.

2usando o sinal SIGALRM + alarm()

a precisão desse método pode alcançar1segundos, onde é utilizado*no mecanismo de semáforos do sistema Nix, primeiro registre a função de tratamento do sinal SIGALRM, chame alarm(), configure o comprimento do temporizador, o código é o seguinte:

#include <stdio.h>
#include <signal.h>
void timer(int sig)
{
    se(SIGALRM == sig)
    {
        printf("timer\n");
        alarm(1);    //continuamos a configurar o temporizador
    }
    return ;
}
int main()
{
    signal(SIGALRM, timer); //relacionar o sinal e a função
    alarm(1);    //acionar o temporizador
    getchar();
    return 0;
}

O modo alarm é bom, mas não pode ser inferior a1com precisão de segundos.

3usando o mecanismo RTC

O mecanismo RTC utiliza o mecanismo de Relógio de Tempo Real fornecido pelo hardware do sistema, lendo o hardware RTC/dev/A RTC, através de ioctl(), configura a frequência RTC, o código é o seguinte:

#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);
    se(fd < 0)
    {
        perror("open");
        exit(errno);
    }
    /*Definir a freqüência como 4Hz*/
    se(ioctl(fd, RTC_IRQP_SET, 1) < 0)
    {
        perror("ioctl(RTC_IRQP_SET)");
        close(fd);
        exit(errno);
    }
    /* Habilitar interrupções periódicas */
    se(ioctl(fd, RTC_PIE_ON, 0) < 0)
    {
        perror("ioctl(RTC_PIE_ON)");
        close(fd);
        exit(errno);
    }
    para(i = 0; i < 100; i++)
    {
        se(read(fd, &data, sizeof(unsigned long)) < 0)
        {
            perror("read");
            close(fd);
            exit(errno);
        }
        printf("timer\n");
    }
    /* Desabilitar interrupções periódicas */
    ioctl(fd, RTC_PIE_OFF, 0);
    close(fd);
    return 0;
}

Este método é mais conveniente, utiliza o RTC fornecido pelo hardware do sistema operacional, a precisão é ajustável e muito alta.

4usando select()

Este método foi visto no livro APUE, é um método menos conhecido, usa select() para configurar o temporizador; o princípio utiliza o5um parâmetro, o primeiro parâmetro é configurado para 0, três conjuntos de descritores de arquivo são configurados como NULL, o5um parâmetro é a estrutura de tempo, o código é o seguinte:

#include <sys/time.h>
#include <sys/select.h>
#include <time.h>
#include <stdio.h>
/*seconds: os segundos; mseconds: os microsegundos*/
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;
}

Este método pode alcançar a precisão de nível de microssegundo, há muitos timers multithreading baseados em select() na internet, o que mostra que a estabilidade do select() ainda é muito boa.

Resumo:Se as exigências do sistema forem baixas, você pode considerar usar o simples sleep(), afinal, uma linha de código resolve; se o sistema exigir precisão alta, pode considerar o mecanismo RTC e o mecanismo select().

Isso é tudo que o editor trouxe para você sobre várias maneiras de implementar timers no Linux, esperamos que você dê apoio e aplauso ao tutorial ~