Como usar o SigalRM e a função de alarme na linguagem C?

O alarme() A função é usada para gerar um Sigalrm sinal após uma quantidade especificada de tempo decorrido. Neste artigo, vamos mostrar como usar alarme() função e Sigalrm sinal no Linux. Então vamos começar.

Sintaxe

Alarme int não assinado (não assinado segundos)

A função é definida em unistd.h arquivo de cabeçalho.

Argumentos

A função leva um argumento, segundos. Depois segundos segundos se passaram desde que solicitou o alarme() função, o Sigalrm o sinal é gerado. O comportamento padrão no recebimento de Sigalrm é encerrar o processo. Mas, podemos pegar e lidar com o sinal. Veja detalhes de manuseio de sinal.

O alarme() A função retornará um valor não zero, se outro alarme tiver sido definido anteriormente e o valor for o número de segundos restantes para o alarme agendado anterior devido ao entregue. De outra forma alarme() retornará zero.

Exemplo 1.C:

#incluir
#incluir
#incluir
void sig_handler (int signum)
printf ("Função do manipulador interno \ n");

int main ()
sinal (sigalrm, sig_handler); // Registre o manipulador de sinal
alarme (2); // alarme agendado após 2 segundos
para (int i = 1 ;; i ++)
printf ("%d: função principal interna \ n", i);
sono (1); // atraso por 1 segundo

retornar 0;

Na captura de tela da saída de Exemplo 1.c, O programa é executado usando o comando time, para que possamos obter uma visão geral do tempo de execução do programa. Observamos que na função principal chamamos alarme() função, programada para 2 segundos. Portanto, para o loop está executando, após 2 segundos a função SIG_HANDLER é chamada e a execução da função principal é pausada. Após a execução da função SIG_HANDLER, na função principal para execução de loop é retomada. Aqui usamos a função do sono para atrasar para que possamos entender o fluxo da execução. O loop for um loop infinito, quando pressionamos uma tecla de interrupção (Ctrl+C), a execução vai parar.

Gerando Sigalrm usando sinal() A função não pode ser empilhada. Apenas um Sigalrm A geração pode ser agendada. Chamadas sucessivas de sinal() Função Redefina o despertador do processo de chamada.

Exemplo2.C:

#incluir
#incluir
#incluir
void sig_handler (int signum)
printf ("Função do manipulador interno \ n");

int main ()
sinal (sigalrm, sig_handler); // Registre o manipulador de sinal
alarme (4); // alarme agendado após 4 segundos
alarme (1); // alarme agendado após 1 segundos
para (int i = 1 ;; i ++)
printf ("%d: função principal interna \ n", i);
sono (1); // atraso por 1 segundo

retornar 0;

Na captura de tela da saída de Exemplo2.c, Podemos ver que o programa executou mais de 7 segundos, mas o primeiro alarme que foi agendado após 4 segundos não está chamando a função do manipulador. O segundo alarme que foi agendado após 1 segundo é redefinido o alarme.

Se o valor do argumento segundos for zero, qualquer solicitação de alarme feita anteriormente será cancelada.

Exemplo3.C:

#incluir
#incluir
#incluir
void sig_handler (int signum)
printf ("Função do manipulador interno \ n");

int main ()
sinal (sigalrm, sig_handler); // Registre o manipulador de sinal
alarme (2); // alarme agendado após 2 segundos
alarme (0); // cancelou o alarme anterior
para (int i = 1 ;; i ++)
printf ("%d: função principal interna \ n", i);
sono (1); // atraso por 1 segundo

retornar 0;

Na captura de tela da saída de Exemplo3.c, Podemos ver que o primeiro alarme que foi agendado após 2 segundos é cancelado devido ao segundo alarme por 0 segundos.

Em Exemplo4.c Veremos como continuamente podemos definir um alarme para cada 2 segundos.

Exemplo4.C:

#incluir
#incluir
#incluir
void sig_handler (int signum)
printf ("Função do manipulador interno \ n");
alarme (2); // agende um novo alarme após 2 segundos

int main ()
sinal (sigalrm, sig_handler); // Registre o manipulador de sinal
alarme (2); // agende o primeiro alarme após 2 segundos
para (int i = 1 ;; i ++)
printf ("%d: função principal interna \ n", i);
pausa(); // esperando até que o sinal seja tratado

retornar 0;

Na captura de tela da saída de Exemplo4.c, Podemos ver que o alarme é contínuo a cada 2 segundos. Redefinimos o alarme na função SIG_HANDLER.

Em Exemplo5.c Veremos como podemos atrasar o alarme já agendado. Usaremos o sinal SIGINT para interrupção. Quando o usuário tipo Ctrl+C no teclado, Sigint o sinal gerará.

Exemplo5.C:

#incluir
#incluir
#incluir
void sig_handler (int signum)
if (signum == sigalrm) // manipulador de sinal para sigalrm
printf ("Função do manipulador interno para Sigalrm \ n");
alarme (2);

if (signum == sigint) // manipulador de sinal para sigint
printf ("\ nsnoozing por 5 segundos… \ n");
alarme (5);


int main ()
sinal (sigalrm, sig_handler); // Registre manipulador de sinal para Sigalrm
sinal (sigint, sig_handler); // Registre o manipulador de sinal para SIGINT
alarme (2); // agende o primeiro alarme após 2 segundos
para (int i = 1 ;; i ++)
printf ("%d: função principal interna \ n", i);
pausa(); // esperando até que o sinal seja tratado

retornar 0;

Na captura de tela da saída de Exemplo5.c, Podemos ver que, quando o tipo de usuário Ctrl+C o alarme é redefinido 5 segundos. Neste programa, usamos apenas uma função de manipulador para dois sinais diferentes, mas na função manipuladora foi verificada para o qual o sinal a função do manipulador está sendo chamada.

Conclusão:

Então, vimos que a função de alarme pode ser definida para o sinal de acionamento, como redefinir o alarme, como cancelar o alarme já agendado.