C Academy · Leçon

Signaux

Notifications asynchrones

Signaux est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce qu'un signal

Un signal est une notification asynchrone envoyée à un processus pour l'informer qu'un événement s'est produit, par exemple lorsqu'un utilisateur appuie sur Ctrl-C ou qu'un processus enfant se termine. Les signaux constituent une forme légère d'IPC.

Signaux courants

Voici quelques signaux que vous rencontrerez souvent :

SIGINT interruption (Ctrl-C)
SIGTERM demande d'arrêt courtoise
SIGKILL arrêt forcé (ne peut pas être intercepté)
SIGCHLD un enfant a changé d'état
SIGSEGV accès mémoire invalide

Dispositions par défaut

Chaque signal possède une action par défaut : terminer, terminer avec vidage mémoire, ignorer, arrêter ou continuer. Vous pouvez remplacer la plupart de ces actions avec un gestionnaire.

Installer un gestionnaire

La manière moderne et portable de définir un gestionnaire est d'utiliser sigaction. Le gestionnaire est une fonction qui reçoit le numéro du signal.

#include <signal.h>
#include <stdio.h>

void on_signal(int sig) {
    /* note: printf is not async-signal-safe; for demo only */
    write(1, "caught\n", 7);
}

int install(void) {
    struct sigaction sa = {0};
    sa.sa_handler = on_signal;
    return sigaction(SIGINT, &sa, NULL);
}

Pourquoi ne pas utiliser signal()

L'ancienne fonction signal() a un comportement incohérent selon les systèmes (réinitialisation du gestionnaire, absence de contrôle de SA_RESTART). Préférez sigaction, dont le comportement est bien défini et portable.

Fonctions sûres pour les signaux asynchrones

Un gestionnaire peut interrompre votre code à n'importe quel moment : il ne doit donc appeler que des fonctions sûres pour les signaux asynchrones, comme write. Appeler printf ou malloc depuis un gestionnaire peut provoquer un interblocage ou une corruption.

Utiliser un indicateur volatile

Voici un schéma sûr : le gestionnaire définit un indicateur volatile sig_atomic_t, et la boucle principale le vérifie. Le gestionnaire reste ainsi minimal et sûr.

#include <signal.h>

volatile sig_atomic_t stop = 0;

void handler(int sig) {
    stop = 1; /* only set a flag */
}
/* main loop: while (!stop) { do_work(); } */

Envoyer des signaux

Utilisez kill(pid, sig) pour envoyer un signal à un autre processus, ou raise(sig) pour vous en envoyer un. Malgré son nom, kill envoie n'importe quel signal, pas uniquement des signaux létaux.

#include <signal.h>

int notify(int pid) {
    return kill(pid, SIGTERM); /* ask process to terminate */
}

Bloquer des signaux

Pour protéger une section critique, bloquez temporairement les signaux avec sigprocmask et un ensemble de signaux. Les signaux bloqués restent en attente et sont délivrés dès qu'ils ne sont plus bloqués.

#include <signal.h>

void block_int(void) {
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    sigprocmask(SIG_BLOCK, &set, NULL);
}

Récupérer les processus enfants avec SIGCHLD

Lorsqu'un processus enfant se termine, le noyau envoie SIGCHLD. Un gestionnaire qui appelle waitpid récupère le processus enfant et évite ainsi les processus zombies qui restent dans la table des processus.

#include <signal.h>
#include <sys/wait.h>

void reap(int sig) {
    while (waitpid(-1, NULL, WNOHANG) > 0)
        ; /* reap all finished children */
}

Les signaux qui ne peuvent pas être interceptés

Deux signaux sont absolus : SIGKILL termine toujours le processus et SIGSTOP l'arrête toujours. Ils ne peuvent être interceptés, bloqués ni ignorés, ce qui garantit au système un moyen de contrôler les processus.

Vérification rapide

Testez votre compréhension des signaux.

Récapitulatif

Vous avez appris à utiliser les signaux pour les notifications asynchrones.

Installez les gestionnaires avec sigaction, et non avec l'ancien signal
Les gestionnaires doivent être sûrs pour les signaux asynchrones : préférez définir un indicateur
Envoyez les signaux avec kill/raise et bloquez-les avec sigprocmask
Récupérez les processus enfants avec SIGCHLD : SIGKILL et SIGSTOP ne peuvent pas être interceptés

Questions Fréquemment Posées

La leçon « Signaux » est-elle gratuite ?

Oui — le texte complet de « Signaux » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Signaux » ?

Notifications asynchrones Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C Academy ?

Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Signaux » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C Academy ?

Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C Academy