Phenquestions
Sintassi
unsigned int alarm (unsigned int secondi)La funzione è definita in unistd.h file di intestazione.
argomenti
La funzione accetta un argomento, secondi. Dopo secondi sono trascorsi secondi dalla richiesta del allarme() funzione, il SIGALRM il segnale viene generato. Il comportamento predefinito al ricevimento di SIGALRM è terminare il processo. Ma possiamo catturare e gestire il segnale. Vedi i dettagli sulla gestione del segnale.
Il allarme() la funzione restituirà un valore diverso da zero, se è stato precedentemente impostato un altro allarme e il valore è il numero di secondi rimanenti per l'allarme programmato precedente dovuto alla consegna. Altrimenti allarme() restituirà zero.
Esempio 1.c:
#includere#includere
#includere
void sig_handler(int signum)
printf("Funzione del gestore interno\n");
int main()
signal(SIGALRM,sig_handler); // Registra il gestore del segnale
allarme(2); // Allarme programmato dopo 2 secondi
for(int i=1;;i++)
printf("%d : All'interno della funzione principale\n",i);
dormire (1); // Ritardo di 1 secondo
restituisce 0;
Nello screenshot dell'output di Esempio 1.c, il programma viene eseguito utilizzando il comando time, in modo da poter avere una panoramica del tempo di esecuzione del programma. Abbiamo osservato che nella funzione principale chiamiamo allarme() funzione, programmata per 2 secondi. Quindi, il ciclo for è in esecuzione, dopo 2 secondi viene chiamata la funzione sig_handler e l'esecuzione della funzione principale viene messa in pausa. Dopo l'esecuzione della funzione sig_handler, nella funzione principale viene ripresa l'esecuzione del ciclo resume. Qui usiamo la funzione sleep per ritardare in modo che possiamo capire il flusso dell'esecuzione. Il ciclo for è un ciclo infinito, quando premiamo un tasto di interruzione (Ctrl+C), l'esecuzione si fermerà.
Generazione SIGALRM usando segnale() la funzione non può essere impilata. Solo uno SIGALRM la generazione può essere programmata. Chiamate successive di segnale() funzione resetta la sveglia del processo di chiamata calling.
Esempio2.c:
#includere#includere
#includere
void sig_handler(int signum)
printf("Funzione del gestore interno\n");
int main()
signal(SIGALRM,sig_handler); // Registra il gestore del segnale
allarme(4); // Allarme programmato dopo 4 secondi
allarme(1); // Allarme programmato dopo 1 secondo
for(int i=1;;i++)
printf("%d : All'interno della funzione principale\n",i);
dormire (1); // Ritardo di 1 secondo
restituisce 0;
Nello screenshot dell'output di Esempio2.c, possiamo vedere che il programma è stato eseguito per più di 7 secondi ma il primo allarme programmato dopo 4 secondi non sta chiamando la funzione handler. Il secondo allarme che è stato programmato dopo 1 secondo viene ripristinato l'allarme.
Se il valore dell'argomento secondi è zero, qualsiasi richiesta di allarme precedentemente effettuata viene annullata.
Esempio3.c:
#includere#includere
#includere
void sig_handler(int signum)
printf("Funzione del gestore interno\n");
int main()
signal(SIGALRM,sig_handler); // Registra il gestore del segnale
allarme(2); // Allarme programmato dopo 2 secondi
allarme(0); // Annullato l'allarme precedente
for(int i=1;;i++)
printf("%d : All'interno della funzione principale\n",i);
dormire (1); // Ritardo di 1 secondo
restituisce 0;
Nello screenshot dell'output di Esempio3.c, possiamo vedere che il primo allarme programmato dopo 2 secondi viene annullato a causa del secondo allarme per 0 secondi.
Nel Esempio4.c vedremo quanto continuamente possiamo impostare una sveglia ogni 2 secondi.
Esempio4.c:
#includere#includere
#includere
void sig_handler(int signum)
printf("Funzione del gestore interno\n");
allarme(2); // Pianifica un nuovo allarme dopo 2 secondi
int main()
signal(SIGALRM,sig_handler); // Registra il gestore del segnale
allarme(2); // Pianifica il primo allarme dopo 2 secondi
for(int i=1;;i++)
printf("%d : All'interno della funzione principale\n",i);
pausa(); // aspetta che il segnale venga gestito
restituisce 0;
Nello screenshot dell'output di Esempio4.c, possiamo vedere che l'allarme è continuo ogni 2 secondi. Resettiamo l'allarme nella funzione sig_handler.
Nel Esempio5.c vedremo come possiamo ritardare la sveglia già programmata. Useremo il segnale SIGINT per l'interruzione. Quando l'utente digita Ctrl+C sulla tastiera, SIGINT il segnale genererà.
Esempio5.c:
#includere#includere
#includere
void sig_handler(int signum)
if(signum == SIGALRM) //gestore del segnale per SIGALRM
printf("Funzione del gestore interno per SIGALRM\n");
allarme(2);
if(signum == SIGINT) // gestore del segnale per SIGINT
printf("\nRiposo per 5 secondi... \n");
allarme(5);
int main()
signal(SIGALRM,sig_handler); // Registra il gestore del segnale per SIGALRM
signal(SIGINT,sig_handler); // Registra il gestore del segnale per SIGINT
allarme(2); // Pianifica il primo allarme dopo 2 secondi
for(int i=1;;i++)
printf("%d : All'interno della funzione principale\n",i);
pausa(); // aspetta che il segnale venga gestito
restituisce 0;
Nello screenshot dell'output di Esempio5.c, possiamo vedere che quando l'utente digita Ctrl+C l'allarme viene ripristinato 5 secondi. In questo programma abbiamo utilizzato una sola funzione handler per due segnali diversi ma nella funzione handler è stato verificato per quale segnale viene chiamata la funzione handler.
Conclusione:
Quindi, abbiamo visto come impostare la funzione di allarme per l'attivazione del segnale, come ripristinare l'allarme, come annullare l'allarme già programmato.
