NSI (Spé) — Architectures matérielles et systèmes d'exploitation
Processus, ordonnancement et interblocage
Gestion des processus, états d'un processus, algorithmes d'ordonnancement, interblocage (deadlock)
Résumé synthétiqueFiche en 4 sectionsQuiz de 10 questionsGratuit, sans pub
Résumé
Ton ordinateur fait « tourner » des dizaines de programmes à la fois sur un nombre limité de cœurs : comment ? Grâce aux **processus** et à l'**ordonnanceur** du système. Un **processus** est un programme **en cours d'exécution**, avec son identifiant (PID), sa mémoire et son **état** : prêt, élu ou bloqué. L'**ordonnanceur** distribue le processeur entre les processus prêts, le plus souvent par **tourniquet (Round Robin)** : un petit **quantum** de temps chacun, à tour de rôle. Mais la concurrence a ses pièges : l'**interblocage (deadlock)**, où deux processus s'attendent mutuellement sans fin. Quatre conditions de Coffman le rendent possible — en briser une seule suffit à l'éviter.
Un **processus** est un programme **en cours d'exécution**, accompagné de son contexte (mémoire, registres, PID). Au fil de sa vie, il passe par trois **états**, au gré des décisions de l'ordonnanceur et de ses besoins en ressources.
- **Processus = programme en exécution + contexte** (registres, mémoire, **PID** unique).
- **Trois états :** **prêt** (attend le processeur), **élu** (l'utilise), **bloqué** (attend une ressource ou une E/S).
- **Transitions :** prêt→élu (choisi), élu→prêt (quantum expiré), élu→bloqué (attend une E/S), bloqué→prêt (E/S finie).
- Un processus peut **créer des fils** (fork). Le tout premier est le **PID 1** (init/systemd).
- **Programme vs processus :** le programme est un **fichier** sur le disque ; le processus, son **exécution** en mémoire.
- Sous Linux : **ps** liste les processus, **top/htop** en temps réel, **kill** PID en termine un.
Exemple
Tu lances un éditeur : il devient **élu** et écrit à l'écran. Tu ouvres un gros fichier : il passe **bloqué** (il attend le disque). La lecture finie, il redevient **prêt**, puis **élu** dès que l'ordonnanceur le rappelle.
Piège à éviter
Un même programme (un fichier .py) peut donner **plusieurs processus** simultanés, chacun avec son PID et sa mémoire isolée. Programme et processus ne sont pas synonymes.
Plusieurs processus sont **prêts**, un seul cœur : l'**ordonnanceur** tranche qui s'exécute et combien de temps. Plusieurs stratégies existent, chacune avec ses compromis entre simplicité, équité et temps d'attente.
- L'**ordonnanceur** choisit quel processus **prêt** obtient le processeur.
- **FCFS** (premier arrivé, premier servi) : simple, mais **effet de convoi** (un long bloque les courts).
- **SJF** (plus court d'abord) : optimal pour le temps moyen, mais il faut **connaître la durée** à l'avance.
- **Round Robin (tourniquet) :** un **quantum** fixe (ex. 20 ms) chacun, puis retour en fin de file.
- **Avec priorités :** le plus prioritaire passe d'abord — risque de **famine** pour les basses priorités.
Exemple
Round Robin, quantum de 20 ms, trois processus A, B, C : A s'exécute 20 ms, puis B 20 ms, puis C 20 ms, puis on revient à A. Aucun ne monopolise le processeur : le système reste réactif.
Piège à éviter
L'ordonnancement **ne garantit pas un ordre déterministe** : relancer le même programme peut donner un entrelacement différent. Ne jamais supposer un ordre précis entre processus concurrents.
Quand des processus se partagent des ressources, ils peuvent se retrouver **bloqués à jamais**, chacun attendant ce que l'autre détient : c'est l'**interblocage**. Coffman a identifié quatre conditions toutes nécessaires — en briser une l'empêche.
- **Interblocage :** des processus bloqués indéfiniment, chacun attendant une ressource tenue par un autre.
- Exemple : P1 tient l'imprimante et veut le scanner ; P2 tient le scanner et veut l'imprimante.
- **4 conditions (Coffman) :** exclusion mutuelle, détention et attente, **non-préemption**, **attente circulaire**.
- **Prévention :** briser une condition, ex. imposer un **ordre d'acquisition** des ressources (casse l'attente circulaire).
- **Détection :** chercher un **cycle** dans le graphe d'allocation des ressources.
- **Approche de l'autruche :** ignorer le problème, car les interblocages sont rares (souvent choisi en pratique).
Exemple
P1 verrouille A puis attend B ; P2 verrouille B puis attend A : aucun ne lâche, blocage total. Solution : imposer que **tous** verrouillent d'abord A, puis B — l'attente circulaire devient impossible.
Piège à éviter
Les **quatre** conditions de Coffman doivent être réunies **simultanément**. Il suffit d'en briser **une seule** (souvent l'attente circulaire) pour rendre tout interblocage impossible.
Chaque processus croit disposer de toute la mémoire : c'est l'illusion de la **mémoire virtuelle**. Mais dès que plusieurs accèdent à une ressource partagée, il faut **protéger** les sections critiques pour éviter les incohérences.
- Chaque processus a son **espace d'adressage** isolé (mémoire virtuelle), protégé des autres.
- La **mémoire virtuelle** permet d'utiliser plus que la RAM physique grâce au **swap** (pagination sur disque).
- **Concurrence :** gérer plusieurs tâches « en même temps » (entrelacées sur un cœur, ou réellement parallèles).
- **Section critique :** code accédant à une ressource partagée ; à protéger par un **verrou (mutex)** ou un **sémaphore**.
- Sans protection : **conditions de course** (le résultat dépend de l'ordre d'exécution).
Exemple
Deux processus incrémentent le même compteur partagé : sans verrou, ils peuvent lire la même valeur 5 et écrire 6 chacun → on perd un incrément. Un **mutex** sérialise l'accès et garantit 7.
Piège à éviter
Ne confonds pas **parallélisme** (vraiment simultané, sur plusieurs cœurs) et **concurrence** (gérer plusieurs tâches, même sur un seul cœur en alternance rapide). On peut être concurrent sans être parallèle.
Quiz - Processus, ordonnancement et interblocage
10 questions
Questions fréquentes
Les points clés à retenir sur Processus, ordonnancement et interblocage, extraits du quiz de révision.
Quels sont les trois états principaux d'un processus ?
Réponse :
Prêt, élu, bloqué
Les trois états principaux sont : prêt (attend le processeur), élu (utilise le processeur) et bloqué (attend une ressource comme une E/S).
L'algorithme Round Robin attribue à chaque processus :
Réponse :
Un quantum de temps fixe
Le Round Robin (tourniquet) attribue un quantum de temps fixe à chaque processus. À l'expiration du quantum, le processus retourne en file d'attente.
Quelle condition N'EST PAS nécessaire à l'interblocage ?
Réponse :
Préemption des ressources
Les quatre conditions nécessaires sont : exclusion mutuelle, détention et attente, NON-préemption et attente circulaire. La préemption (pouvoir reprendre une ressource) empêcherait l'interblocage.
Qu'est-ce qu'un PID ?
Réponse :
L'identifiant unique d'un processus
PID (Process ID) est l'identifiant unique attribué par le système d'exploitation à chaque processus en cours d'exécution.