Processus, appels système et threads
Mode utilisateur et mode noyau, appels système, états d'un processus, changement de contexte, fork et exec avec le nombre de processus démontré, threads, tubes et communication entre processus.
https://www.electronics-engineering.com/fr/processus-appels-systeme-fork-threads/
Un système d’exploitation fait deux métiers : il offre aux programmes une abstraction commode de la machine (des fichiers au lieu de secteurs de disque, des processus au lieu de registres du processeur) et il gère ses ressources pour que de nombreux programmes puissent coexister sans se nuire. Le concept central est le processus, un programme en cours d’exécution. Dans cette leçon, nous regardons le mode protégé et les appels système, la structure d’un processus et ses états, le changement de contexte, la création de processus sous Unix avec la démonstration du nombre de processus qui naissent d’une suite de fork, les threads et la communication entre processus.
Mode utilisateur et mode noyau
Le processeur a au moins deux niveaux de privilège (leçon de Systèmes d’élaboration sur les entrées et sorties). En mode noyau, on peut exécuter toutes les instructions et accéder à toute la mémoire et à tous les périphériques ; en mode utilisateur, les instructions privilégiées provoquent une exception. Les programmes tournent en mode utilisateur ; quand ils ont besoin d’un service (lire un fichier, créer un processus, allouer de la mémoire), ils exécutent un appel système : une instruction spéciale (trap) passe le contrôle au noyau en un point fixe, le noyau vérifie les paramètres, effectue le service et renvoie le résultat, en revenant au mode utilisateur.
Le passage coûte de dizaines à centaines de nanosecondes, bien plus qu’un appel de fonction : c’est pourquoi les bibliothèques regroupent les opérations (par exemple la fonction C printf accumule les caractères dans un tampon et n’appelle le noyau qu’une fois).
Le processus
Un processus se compose :
- d’un espace d’adressage privé : code, données globales, tas (mémoire allouée dynamiquement) et pile (leçon de Fondements de l’informatique sur la mémoire dynamique) ;
- de l’état du processeur : compteur de programme, registres, pointeur de pile ;
- de ressources système : fichiers ouverts, permissions, identifiant (PID), processus parent.
Le noyau garde tout cela dans un descripteur de processus (PCB, process control block). Au cours de sa vie, un processus passe par plusieurs états.

Sur un CPU, un seul processus tourne à la fois ; les autres prêts attendent dans une file, et ceux en attente attendent un événement (la fin d’une lecture de disque, un paquet du réseau, une touche pressée). Choisir qui s’exécute est le travail de l’ordonnanceur (leçon sur l’ordonnancement).
Le changement de contexte
Pour passer d’un processus à un autre, le noyau sauvegarde les registres du premier dans son PCB, charge ceux du second et change l’espace d’adressage (la table des pages, leçon sur la mémoire virtuelle). Le changement prend quelques microsecondes, mais le vrai coût est indirect : les caches et le TLB contiennent des données du processus précédent et se remplissent de nouveau, lentement. Un ordonnanceur qui change trop souvent gaspille la machine.
Créer des processus sous Unix
Sous Unix, un processus naît en clonant un autre avec l’appel fork : le fils est une copie du père (même mémoire, mêmes fichiers ouverts), et fork renvoie 0 dans le fils et le PID du fils dans le père. Pour exécuter un autre programme, le fils appelle exec, qui remplace son code. Le père peut attendre la fin du fils avec wait.
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main(void) {
pid_t pid = fork();
if (pid == 0) { /* child */
execlp("ls", "ls", "-l", NULL); /* becomes the ls program */
perror("exec"); /* reached only if exec fails */
return 1;
}
waitpid(pid, NULL, 0); /* the parent waits for the child */
printf("child %d finished\n", pid);
return 0;
}Copier toute la mémoire serait lent ; les systèmes modernes utilisent la copie sur écriture (copy-on-write) : père et fils partagent les pages, marquées en lecture seule, et une page n’est dupliquée que quand l’un des deux la modifie.
Théorème. Un programme qui exécute
appels fork en séquence, sans vérifier leur résultat, produit
processus en tout.
Démonstration. Par récurrence sur
. Avec
, il n’y a que le processus initial,
. Supposons qu’après
fork il y ait
processus ; chacun continue d’où il en est et exécute le fork suivant, en créant un fils. Les processus deviennent
. ∎
Avec
, on obtient 1024 processus : c’est le principe de la « fork bomb », dont on se défend en limitant le nombre de processus par utilisateur.
Les threads
Un thread est un flot d’exécution à l’intérieur d’un processus : il a ses propres registres et sa pile, mais partage la mémoire et les fichiers avec les autres threads du même processus. En créer un et passer d’un thread à l’autre coûte moins que pour des processus, et la communication est immédiate par la mémoire partagée. Le prix est que chaque accès partagé doit être synchronisé (leçon sur la synchronisation), et qu’un bogue dans un thread peut corrompre tout le processus. On utilise les threads pour exploiter plusieurs cœurs (leçon sur les systèmes multicœurs) et pour éviter de bloquer un programme interactif pendant qu’il attend le disque ou le réseau.
La communication entre processus
Des processus séparés communiquent par l’intermédiaire du noyau :
- les tubes (pipes) : un canal d’octets à sens unique entre deux processus ; le shell les utilise pour relier des commandes, comme dans ls | grep txt, où la sortie de la première devient l’entrée de la seconde ;
- la mémoire partagée : une zone projetée dans les espaces d’adressage de plusieurs processus, très rapide mais qui demande de la synchronisation ;
- les files de messages et les sockets, qui fonctionnent aussi entre machines différentes (leçon de Réseaux de télécommunication sur l’architecture en couches) ;
- les signaux : des notifications asynchrones, comme l’interruption par Ctrl-C.
Les filtres Unix, de petits programmes qui lisent un flux de texte et le transforment, comme sed, grep et sort, se composent avec des tubes en chaînes puissantes : c’est la philosophie « faire une seule chose et la faire bien ».






Benvenuti nella pagina su «Processi, chiamate di sistema e thread». L'ho scritta pensando a chi studia ingegneria elettronica: se un passaggio non vi torna, un esercizio vi dà un risultato diverso o volete altro materiale sull'argomento, chiedete pure nei commenti e vi risponderò. Un voto con le stelle qui sopra mi aiuta a capire quali pagine migliorare.Welcome to the page on “Processes, system calls and threads”. I wrote it for engineering students: if a step does not add up, an exercise gives you a different result or you would like more material on the topic, just ask in the comments and I will reply. A star rating above helps me understand which pages to improve.