Comment utiliser Sigalrm et la fonction d'alarme dans le langage C?

Le alarme() La fonction est utilisée pour générer un Sigalrm signal après un temps spécifié écoulé. Dans cet article, nous allons vous montrer comment utiliser alarme() fonction et Sigalrm Signal dans Linux. Alors, commençons.

Syntaxe

ALARME INTES UNSIGNÉ (UNSIGNED INT SECONDES)

La fonction est définie dans unistd.H En tête de fichier.

Arguments

La fonction prend un argument, secondes. Après secondes Des secondes se sont écoulées depuis que alarme() fonction, le Sigalrm Le signal est généré. Le comportement par défaut sur réception de Sigalrm est de terminer le processus. Mais, nous pouvons attraper et gérer le signal. Voir les détails de la gestion du signal.

Le alarme() La fonction renvoie une valeur non zéro, si une autre alarme a été précédemment définie et que la valeur est le nombre de secondes restantes pour l'alarme planifiée précédente en raison de la livraison. Sinon alarme() retournera zéro.

Exemple 1.C:

#inclure
#inclure
#inclure
void sig_handler (int Signum)
printf ("Inside Handler function \ n");

int main()
Signal (Sigalrm, SIG_HANDLER); // Enregistrer le gestionnaire de signaux
alarme (2); // Alarme planifiée après 2 secondes
pour (int i = 1 ;; i ++)
printf ("% d: inside principal fonction \ n", i);
sommeil (1); // retard de 1 seconde

retour 0;

Dans la capture d'écran de la sortie de Exemple 1.c, Le programme est exécuté à l'aide de la commande Time, afin que nous puissions obtenir un aperçu du temps d'exécution du programme. Nous avons observé que dans la fonction principale, nous appelons alarme() fonction, prévue pendant 2 secondes. Ainsi, pour Loop s'exécute, après 2 secondes, la fonction SIG_HANDLER est appelée et l'exécution de la fonction principale est interrompue. Après l'exécution de la fonction SIG_HANDLER, dans la fonction principale pour l'exécution de la boucle est reproduite. Ici, nous utilisons la fonction de sommeil pour retarder afin que nous puissions comprendre le flux de l'exécution. La boucle FOR est une boucle infinie, lorsque nous appuyons sur une touche d'interruption (Ctrl + C), l'exécution s'arrêtera.

Générateur Sigalrm en utilisant signal() La fonction ne peut pas être empilée. Seulement un Sigalrm La génération peut être programmée. Appels successifs de signal() fonction réinitialise le réveil du processus d'appel.

Exemple2.C:

#inclure
#inclure
#inclure
void sig_handler (int Signum)
printf ("Inside Handler function \ n");

int main()
Signal (Sigalrm, SIG_HANDLER); // Enregistrer le gestionnaire de signaux
alarme (4); // Alarme planifiée après 4 secondes
alarme (1); // Alarme planifiée après 1 seconde
pour (int i = 1 ;; i ++)
printf ("% d: inside principal fonction \ n", i);
sommeil (1); // retard de 1 seconde

retour 0;

Dans la capture d'écran de la sortie de Exemple2.c, Nous pouvons voir que le programme a exécuté plus de 7 secondes, mais la première alarme qui était prévue après 4 secondes n'appelle pas la fonction de gestionnaire. La deuxième alarme qui était prévue après 1 seconde est réinitialisé l'alarme.

Si la valeur des secondes de l'argument est nulle, alors toute demande d'alarme précédemment faite est annulée.

Exemple3.C:

#inclure
#inclure
#inclure
void sig_handler (int Signum)
printf ("Inside Handler function \ n");

int main()
Signal (Sigalrm, SIG_HANDLER); // Enregistrer le gestionnaire de signaux
alarme (2); // Alarme planifiée après 2 secondes
alarme (0); // annulé l'alarme précédente
pour (int i = 1 ;; i ++)
printf ("% d: inside principal fonction \ n", i);
sommeil (1); // retard de 1 seconde

retour 0;

Dans la capture d'écran de la sortie de Exemple3.c, Nous pouvons voir que la première alarme prévue après 2 secondes est annulée en raison de la deuxième alarme pendant 0 seconde.

Dans Exemple4.c Nous verrons à quel point nous pouvons constamment régler une alarme toutes les 2 secondes.

Exemple4.C:

#inclure
#inclure
#inclure
void sig_handler (int Signum)
printf ("Inside Handler function \ n");
alarme (2); // Planifiez une nouvelle alarme après 2 secondes

int main()
Signal (Sigalrm, SIG_HANDLER); // Enregistrer le gestionnaire de signaux
alarme (2); // Planifiez la première alarme après 2 secondes
pour (int i = 1 ;; i ++)
printf ("% d: inside principal fonction \ n", i);
pause(); // en attente du signal est géré

retour 0;

Dans la capture d'écran de la sortie de Exemple4.c, Nous pouvons voir que l'alarme est continue en toutes les 2 secondes. Nous réinitialisons l'alarme dans la fonction SIG_HANDLER.

Dans Exemple5.c Nous verrons comment nous pouvons retarder l'alarme déjà planifiée. Nous utiliserons le signal SIGINT pour l'interruption. Lorsque l'utilisateur type Ctrl + C dans le clavier, Sigint Le signal va générer.

Exemple5.C:

#inclure
#inclure
#inclure
void sig_handler (int Signum)
if (Signum == Sigalrm) // Handler de signal pour Sigalrm
printf ("Fonction de gestionnaire intérieur pour sigalrm \ n");
alarme (2);

if (Signum == Sigint) // Handler de signal pour Sigint
printf ("\ nsnoozing pendant 5 secondes… \ n");
alarme (5);


int main()
Signal (Sigalrm, SIG_HANDLER); // Enregistrer le gestionnaire de signaux pour Sigalrm
Signal (Sigint, Sig_Handler); // Enregistrer le gestionnaire de signaux pour Sigint
alarme (2); // Planifiez la première alarme après 2 secondes
pour (int i = 1 ;; i ++)
printf ("% d: inside principal fonction \ n", i);
pause(); // en attente du signal est géré

retour 0;

Dans la capture d'écran de la sortie de Exemple5.c, Nous pouvons voir que lorsque l'utilisateur type Ctrl + C, l'alarme est réinitialisée 5 secondes. Dans ce programme, nous n'avons utilisé qu'une seule fonction de gestionnaire pour deux signaux différents, mais dans la fonction du gestionnaire, il a été vérifié que pour lequel le signal, la fonction de gestionnaire est appelée.

Conclusion:

Nous avons donc vu que la fonction d'alarme peut être définie pour le déclenchement du signal, comment réinitialiser l'alarme, comment annuler déjà l'alarme planifiée.