Phenquestions
Syntaxe
alarme int non signée (secondes entières non signées)La fonction est définie dans unistd.h En tête de fichier.
Arguments
La fonction prend un argument, secondes. Après secondes secondes se sont écoulées depuis la demande de alarme() fonction, le SIGALRM le signal est généré. Le comportement par défaut à la réception de SIGALRM est de mettre fin au processus. Mais, nous pouvons attraper et gérer le signal. Voir les détails de gestion du signal.
le alarme() fonction renverra une valeur non nulle, si une autre alarme a été précédemment définie et la valeur est le nombre de secondes restantes pour l'alarme programmé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("Fonction de gestionnaire interne\n");
int main()
signal(SIGALRM,sig_handler); // Enregistrer le gestionnaire de signal
alarme(2) ; // Alarme programmée après 2 secondes
for(int i=1;;i++)
printf("%d : Fonction principale interne\n",i);
sommeil(1); // Retard de 1 seconde
renvoie 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 avoir un aperçu du temps d'exécution du programme. Nous avons observé que dans la fonction principale, nous appelons alarme() fonction, programmée pour 2 secondes. Ainsi, la boucle for est en cours d'exécution, 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 reprise. Ici, nous utilisons la fonction sleep 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 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éinitialiser le réveil du processus d'appel.
Exemple2.c :
#inclure#inclure
#inclure
void sig_handler(int signum)
printf("Fonction de gestionnaire interne\n");
int main()
signal(SIGALRM,sig_handler); // Enregistrer le gestionnaire de signal
alarme(4) ; // Alarme programmée après 4 secondes
alarme (1) ; // Alarme programmée après 1 seconde
for(int i=1;;i++)
printf("%d : Fonction principale interne\n",i);
sommeil(1); // Retard de 1 seconde
renvoie 0 ;
Dans la capture d'écran de la sortie de Exemple2.c, on voit que le programme s'est exécuté plus de 7 secondes mais la première alarme qui était programmée après 4 secondes n'appelle pas la fonction handler. La deuxième alarme qui était programmée après 1 seconde est réinitialisée l'alarme.
Si la valeur de l'argument secondes est zéro, alors toute demande d'alarme effectuée précédemment est annulée.
Exemple3.c :
#inclure#inclure
#inclure
void sig_handler(int signum)
printf("Fonction de gestionnaire interne\n");
int main()
signal(SIGALRM,sig_handler); // Enregistrer le gestionnaire de signal
alarme(2) ; // Alarme programmée après 2 secondes
alarme(0) ; // Annulation de l'alarme précédente
for(int i=1;;i++)
printf("%d : Fonction principale interne\n",i);
sommeil(1); // Retard de 1 seconde
renvoie 0 ;
Dans la capture d'écran de la sortie de Exemple3.c, on peut voir que la première alarme qui était programmée après 2 secondes est annulée à cause de la deuxième alarme pendant 0 seconde.
Dans Exemple4.c nous verrons avec quelle continuité nous pouvons régler une alarme toutes les 2 secondes.
Exemple4.c :
#inclure#inclure
#inclure
void sig_handler(int signum)
printf("Fonction de gestionnaire interne\n");
alarme(2) ; // Programmer une nouvelle alarme après 2 secondes
int main()
signal(SIGALRM,sig_handler); // Enregistrer le gestionnaire de signal
alarme(2) ; // Programmer la première alarme après 2 secondes
for(int i=1;;i++)
printf("%d : Fonction principale interne\n",i);
pause(); // attendre que le signal soit traité
renvoie 0 ;
Dans la capture d'écran de la sortie de Exemple4.c, on voit que l'alarme est continue toutes les 2 secondes. On réinitialise l'alarme dans la fonction sig_handler.
Dans Exemple5.c nous verrons comment nous pouvons retarder l'alarme déjà programmée. Nous utiliserons le signal SIGINT pour l'interruption. Lorsque l'utilisateur tape Ctrl+C au clavier, SIGINT le signal générera.
Exemple5.c :
#inclure#inclure
#inclure
void sig_handler(int signum)
if(signum == SIGALRM) //gestionnaire de signal pour SIGALRM
printf("Fonction de gestionnaire interne pour SIGALRM\n");
alarme(2) ;
if(signum == SIGINT) // gestionnaire de signal pour SIGINT
printf("\nRépétition pendant 5 secondes… \n");
alarme(5) ;
int main()
signal(SIGALRM,sig_handler); // Enregistrer le gestionnaire de signal pour SIGALRM
signal(SIGINT,sig_handler); // Enregistrer le gestionnaire de signal pour SIGINT
alarme(2) ; // Programmer la première alarme après 2 secondes
for(int i=1;;i++)
printf("%d : Fonction principale interne\n",i);
pause(); // attendre que le signal soit traité
renvoie 0 ;
Dans la capture d'écran de la sortie de Exemple5.c, nous pouvons voir que lorsque l'utilisateur tape 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 de gestionnaire, il a été vérifié pour quel signal la fonction de gestionnaire est appelée.
Conclusion:
Ainsi, nous avons vu comment la fonction d'alarme peut être définie pour déclencher le signal, comment réinitialiser l'alarme, comment annuler l'alarme déjà programmée.
