Come utilizzare SigalRM e la funzione di allarme in linguaggio C?
Sintassi
Allarme INT non firmato (secondi INT non firmati)La funzione è definita in unistd.H File di intestazione.
argomenti
La funzione prende uno argomento, Secondi. Dopo Secondi Sono trascorsi secondi da quando ho richiesto il allarme() funzione, il Sigalrm Il segnale è generato. Il comportamento predefinito al ricevimento Sigalrm è terminare il processo. Ma possiamo catturare e gestire il segnale. Vedere i dettagli della gestione del segnale.
IL allarme() La funzione restituirà un valore non zero, se un altro allarme è stato precedentemente impostato e il valore è il numero di secondi rimanenti per il precedente allarme programmato a causa di consegna. Altrimenti allarme() tornerà zero.
Esempio 1.C:
#includere#includere
#includere
void sig_handler (int Signum)
printf ("Funzione di gestori interni \ n");
int main ()
segnale (sigalrm, sig_handler); // Registra il gestore del segnale
Allarme (2); // Allarme programmato dopo 2 secondi
per (int i = 1 ;; i ++)
printf ("%d: nella funzione principale \ n", i);
sonno (1); // ritardo per 1 secondo
restituzione 0;
Nello screenshot dell'output di Esempio 1.C, Il programma viene eseguito utilizzando il comando Time, in modo da poter ottenere una panoramica del tempo di esecuzione del programma. Abbiamo osservato che nella funzione principale che chiamiamo allarme() funzione, programmata per 2 secondi. Quindi, per l'esecuzione del ciclo, dopo 2 secondi viene chiamata la funzione SIG_Handler e l'esecuzione della funzione principale è messa in pausa. Dopo l'esecuzione della funzione Sig_Handler, nella funzione principale per l'esecuzione del loop viene ripresa. Qui usiamo la funzione del sonno per il ritardo in modo da poter capire il flusso dell'esecuzione. Il loop è un loop infinito, quando premiamo un tasto di interruzione (Ctrl+C), l'esecuzione si fermerà.
Generare Sigalrm usando segnale() La funzione non può essere impilata. Solo uno Sigalrm La generazione può essere programmata. Chiamate successive di segnale() Funzione Ripristina la sveglia del processo di chiamata.
Esempio2.C :
#includere#includere
#includere
void sig_handler (int Signum)
printf ("Funzione di gestori interni \ n");
int main ()
segnale (sigalrm, sig_handler); // Registra il gestore del segnale
Allarme (4); // Allarme programmato dopo 4 secondi
Allarme (1); // Allarme programmato dopo 1 secondo
per (int i = 1 ;; i ++)
printf ("%d: nella funzione principale \ n", i);
sonno (1); // ritardo per 1 secondo
restituzione 0;
Nello screenshot dell'output di Esempio2.C, Possiamo vedere che il programma ha eseguito più di 7 secondi, ma il primo allarme che è stato programmato dopo 4 secondi non chiama la funzione gestore. Il secondo allarme che è stato programmato dopo 1 secondo viene ripristinato l'allarme.
Se il valore dei secondi dell'argomento è zero, qualsiasi richiesta di allarme precedentemente fatta viene annullata.
Esempio3.C:
#includere#includere
#includere
void sig_handler (int Signum)
printf ("Funzione di gestori interni \ n");
int main ()
segnale (sigalrm, sig_handler); // Registra il gestore del segnale
Allarme (2); // Allarme programmato dopo 2 secondi
allarme (0); // ha annullato l'allarme precedente
per (int i = 1 ;; i ++)
printf ("%d: nella funzione principale \ n", i);
sonno (1); // ritardo per 1 secondo
restituzione 0;
Nello screenshot dell'output di Esempio3.C, Possiamo vedere che il primo allarme che è stato programmato dopo 2 secondi viene annullato a causa del secondo allarme per 0 secondi.
In Esempio4.C Vedremo quanto continuamente possiamo impostare un allarme per ogni 2 secondi.
Esempio4.C:
#includere#includere
#includere
void sig_handler (int Signum)
printf ("Funzione di gestori interni \ n");
Allarme (2); // Pianifica un nuovo allarme dopo 2 secondi
int main ()
segnale (sigalrm, sig_handler); // Registra il gestore del segnale
Allarme (2); // Pianifica il primo allarme dopo 2 secondi
per (int i = 1 ;; i ++)
printf ("%d: nella funzione principale \ n", i);
pausa(); // in attesa di essere gestito il segnale
restituzione 0;
Nello screenshot dell'output di Esempio4.C, Possiamo vedere che l'allarme è continuo ogni 2 secondi. Ripristiniamo l'allarme nella funzione Sig_Handler.
In Esempio5.C Vedremo come possiamo ritardare l'allarme già programmato. Useremo Sigint Signal per l'interruzione. Quando il tipo di utente CTRL+C in 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 di gestore interni per Sigalrm \ n");
Allarme (2);
if (Signum == Sigint) // Handler di segnale per Sigint
printf ("\ nsnoozing per 5 secondi ... \ n");
allarme (5);
int main ()
segnale (sigalrm, sig_handler); // Registra il gestore del segnale per SigalRM
segnale (sigint, sig_handler); // Registra il gestore del segnale per Sigint
Allarme (2); // Pianifica il primo allarme dopo 2 secondi
per (int i = 1 ;; i ++)
printf ("%d: nella funzione principale \ n", i);
pausa(); // in attesa di essere gestito il segnale
restituzione 0;
Nello screenshot dell'output di Esempio5.C, Possiamo vedere che quando il tipo di utente Ctrl+C l'allarme viene ripristinato 5 secondi. In questo programma abbiamo usato solo la funzione di un gestore per due segnali diversi ma nella funzione del gestore è stato verificato che per il quale il segnale viene chiamato la funzione del gestore.
Conclusione:
Quindi, abbiamo visto che la funzione di allarme può essere impostata per il segnale di attivazione, come ripristinare l'allarme, come annullare l'allarme già pianificato.