Por exemplo, se estivermos desenvolvendo uma aplicação de console onde precisamos informar ao usuário as tarefas que serão executadas em sequência, as mensagens informativas deverão persistir por um tempo razoável para que o usuário tenha tempo de lê-las antes de serem apagadas e o programa passa para o próximo comando.
Neste artigo do Linuxhint, você aprenderá como usar a função sleep() para criar atrasos em tempo real. Mostraremos a sintaxe e a descrição desta função, bem como as opções que o POSIX oferece para criar atrasos com frações menores que um segundo. A seguir, usando exemplos práticos, códigos e imagens, mostraremos como atrasar a execução de um programa e os efeitos dos sinais nesta função.
Sintaxe da função Sleep() em linguagem C
não assinado interno dormir ( não assinado interno segundo )
Descrição da função Sleep() em linguagem C
A função sleep() coloca o processo ou thread em suspensão pelo tempo em segundos especificado no argumento de entrada “sec”, que é um número inteiro não assinado. Depois que a função sleep() é chamada, o processo de chamada dorme até atingir o tempo limite ou receber um sinal.
Esta função é frequentemente usada para impor longos atrasos de mais de 1 segundo na execução de processos em tempo real. Para atrasos inferiores a 1 segundo, o POSIX fornece a função de resolução de microssegundos, usleep(), que usa a mesma chamada de método que sleep(). Para atrasos inferiores a 1 microssegundo, existe também a função nanosleep() com resolução de 1 nanossegundo, mas com um método de chamada diferente onde utiliza as estruturas “timespec” como argumentos de entrada para definir o tempo de atraso.
Se a função sleep() consumiu todo o tempo especificado, ela retornará 0 como resultado. Se a execução for interrompida pela chegada de um sinal antes de decorrido o tempo especificado, ela retornará o número de segundos restantes até esse tempo.
A função sleep() é definida no cabeçalho “unistd.h”. Para utilizá-lo, precisamos incluir este arquivo no código da seguinte forma:
#include
Como introduzir atrasos em um processo com a função Sleep()
Neste exemplo, criamos um timer que consiste em um loop infinito no qual imprimimos a mensagem “Tempo decorrido” no console de comando, seguida dos segundos decorridos do processo. Cada um desses loops é repetido a cada 2 segundos devido ao atraso causado pela função sleep().
Para fazer isso, pegamos um arquivo vazio com extensão “.c” e adicionamos os cabeçalhos “stdio.h” e “unistd.h” nele. Em seguida, abrimos uma função main() vazia e definimos nela a variável segundos do tipo int que usaremos como contador do tempo decorrido.
Depois que os cabeçalhos são inseridos e a variável declarada, abrimos um loop infinito e usamos a função printf() nele para exibir a mensagem e o valor do tempo. Na próxima linha, incrementamos a variável time em 2 e então chamamos a função sleep() com o valor 2 como argumento de entrada. Desta forma, este ciclo se repete a cada segundo e obtemos um contador que mostra o tempo decorrido na tela. Agora, vamos dar uma olhada no código deste aplicativo. Vamos ver o código completo deste exemplo:
#include#include
vazio principal ( )
{
interno segundos = 0 ;
enquanto ( 1 )
{
imprimir ( 'Tempo decorrido: %i \n ' , segundos ) ;
segundos += 2 ;
dormir ( 2 ) ;
}
}
A seguir veremos uma imagem com a compilação e execução deste código. Como podemos ver, a cada 2 segundos, o programa imprime na tela os segundos decorridos desde a execução do processo.
Efeito dos sinais na função Sleep()
Neste exemplo, queremos observar o efeito dos sinais em um processo que é colocado em suspensão usando a função sleep(). Para fazer isso, criamos um aplicativo simples que consiste em uma função main() e um manipulador para o sinal 36.
Na primeira linha da função main(), declaramos a variável restante do tipo int onde armazenamos o valor que é retornado pela função sleep(). Em seguida, usamos a função signal() para vincular o manipulador ao sinal 36. Na próxima linha, exibimos o PID do processo que usamos para enviar um sinal de um segundo shell para o processo. Finalmente, chamamos a função sleep() e definimos seu argumento de entrada para 60 segundos, tempo suficiente para enviar um sinal de um segundo shell. Enviamos a variável restante como argumento de saída para sleep().
O manipulador anexado ao sinal 36 consiste em uma linha de código onde a função printf() imprime a mensagem “Tempo restante:” seguida do valor que é retornado por sleep() no momento em que o sinal chega ao processo. Aqui, vamos dar uma olhada no código deste exemplo.
#include#include
#include
#include
vazio manipulador ( interno restante ) ;
vazio principal ( )
{
interno restante ;
sinal ( 36 , manipulador ) ;
imprimir ( 'ID do processo: %i \n ' , obterpid ( ) ) ;
restante = dormir ( 60 ) ;
}
vazio manipulador ( interno restante )
{
imprimir ( 'Tempo restante: %i \n ' , restante ) ;
}
A imagem a seguir que vemos mostra a compilação e execução deste código:
Para ver o efeito dos sinais neste processo, compilamos este código e o executamos. Então, a partir de um segundo terminal, enviamos um sinal com a seguinte sintaxe:
matar - n sinal PIDA imagem a seguir que vemos mostra a execução do código no console anterior e os efeitos da chegada de um sinal enviado do console seguinte. Como você pode ver, o sinal suprimiu o efeito da função sleep() ao ativar o processo:
Conclusão
Neste artigo do Linuxhint, mostramos como usar a função sleep() para colocar um processo em suspensão por um determinado número de segundos. Também mostramos a sintaxe, bem como a descrição da função e do método de chamada.
Usando exemplos práticos, trechos de código e imagens, mostramos como colocar um processo em suspensão e o que afeta a chegada de um sinal em um processo em suspensão usando a função sleep().