Un programme est une recette. Un processus est un cuisinier en train de la suivre.
⏱️ Durée : environ 75 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Chef de processus
🎬 L'histoire
Kodi lance son serveur de test deux fois. Il y a maintenant deux serveurs en même temps, avec deux identifiants différents et chacun ses propres données. Il s'étonne : « C'est le même programme ! »
« Le programme est un fichier, dit Sam. Un processus est un programme en cours d'exécution, avec sa propre mémoire et son propre état. »
Tu apprends à créer, observer et contrôler des processus.
🎯 Ta mission
À la fin, je serai capable de :
- distinguer programme et processus
- décrire les états d'un processus
- expliquer PID, parent, enfant
- créer un processus avec
subprocesset lire son code de sortie - expliquer ce qu'est un processus zombie ou orphelin
🧩 Défi d'échauffement (5 XP)
Une recette de cuisine (le programme) peut être suivie par 3 cuisiniers dans 3 cuisines différentes en même temps. Chacun en est à une étape différente, avec ses propres ingrédients. Qu'est-ce qui appartient à la recette, et qu'est-ce qui appartient à chaque cuisinier ? Que se passe-t-il si l'un se brûle ?
💡 Le concept
Programme et processus
- Programme : un fichier exécutable, inerte.
- Processus : une instance en cours d'exécution, avec :
- un PID (identifiant) ;
- son espace mémoire (code, données, tas, pile) ;
- ses fichiers ouverts ;
- son état et son compteur de programme ;
- un utilisateur propriétaire.
Les états d'un processus
stateDiagram-v2
[*] --> Nouveau
Nouveau --> Prêt
Prêt --> EnCours : l'ordonnanceur choisit
EnCours --> Prêt : temps écoulé
EnCours --> Bloqué : attend (disque, réseau)
Bloqué --> Prêt : l'attente est terminée
EnCours --> Terminé
Terminé --> [*]
Description du schéma : un processus naît (nouveau), devient prêt, puis « en cours » quand il obtient le CPU. Il peut repasser à prêt si son temps est écoulé, ou passer à bloqué s'il attend une ressource, puis revenir à prêt. Il finit à l'état terminé.
Parent et enfants
Un processus est créé par un autre (son parent). Sous Unix, fork crée une copie du processus, puis exec remplace le programme de la copie par un autre. Le premier processus (init ou systemd) a le PID 1.
systemd (PID 1)
└── bash (PID 812)
└── python3 script.py (PID 4120)
Créer un processus en Python
import subprocess, sys
resultat = subprocess.run([sys.executable, "-c", "print('bonjour du fils')"],
capture_output=True, text=True)
print(resultat.stdout.strip()) # bonjour du fils
print(resultat.returncode) # 0
Le code de sortie
Un processus termine avec un code de sortie : 0 = succès, autre valeur = erreur. Les scripts, les outils d'intégration continue et les shells s'appuient dessus.
import subprocess, sys
ok = subprocess.run([sys.executable, "-c", "raise SystemExit(0)"]).returncode
ko = subprocess.run([sys.executable, "-c", "raise SystemExit(3)"]).returncode
print(ok, ko) # 0 3
Cas particuliers
- Zombie : un enfant terminé dont le parent n'a pas encore lu le code de sortie. Il ne consomme presque rien, mais garde une entrée dans la table des processus.
- Orphelin : un enfant dont le parent est mort. Il est adopté par
init.
Isolation
Deux processus ne partagent pas leur mémoire. Pour échanger des données : fichiers, tubes (pipes), sockets, mémoire partagée explicitement.
🧠 Astuce : un processus qui plante n'emporte pas les autres. C'est la grande force de l'isolation.
🔍 Exemple pas à pas
Problème : lancer plusieurs processus fils en parallèle, attendre leurs résultats et récupérer leurs codes de sortie.
import subprocess, sys
travaux = [
"print('A'); raise SystemExit(0)",
"print('B'); raise SystemExit(2)",
"import time; time.sleep(0.2); print('C')",
]
processus = [
subprocess.Popen([sys.executable, "-c", code], stdout=subprocess.PIPE, text=True)
for code in travaux
]
for p in processus:
sortie, _ = p.communicate() # attend la fin et lit la sortie
print(f"PID {p.pid}: sortie={sortie.strip()!r} code={p.returncode}")
Lecture :
- les trois processus tournent en même temps (le dernier attend 0,2 s sans retarder les autres) ;
- chaque processus a son propre PID et son propre code de sortie ;
communicate()attend la fin : c'est aussi ce qui évite de laisser des processus zombies.
Isolation : une variable modifiée dans un fils n'est jamais vue par le parent.
import subprocess, sys
x = 10
subprocess.run([sys.executable, "-c", "x = 99; print('fils x =', x)"])
print("parent x =", x) # parent x = 10
✍️ À toi, avec aide (10 XP)
Écris executer(commande_python) qui lance un petit programme Python dans un processus séparé, avec un délai maximum de 2 secondes, et renvoie un dictionnaire {"sortie": …, "code": …, "expire": True/False}.
Teste avec un programme qui affiche un texte, un programme qui échoue (code 1), et un programme qui dort 5 secondes.
💡 Indice 1
subprocess.run(..., timeout=2) lève subprocess.TimeoutExpired.
💡 Indice 2
Attrape l'exception et renvoie expire: True.
💡 Indice 3
Capture la sortie avec capture_output=True, text=True.
✅ Réponse
import subprocess, sys
def executer(code, delai=2):
try:
r = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True, timeout=delai)
return {"sortie": r.stdout.strip(), "code": r.returncode, "expire": False}
except subprocess.TimeoutExpired:
return {"sortie": "", "code": None, "expire": True}
print(executer("print('ok')"))
print(executer("raise SystemExit(1)"))
print(executer("import time; time.sleep(5)", delai=1))
🚀 À toi, en solo (20 XP)
Superviseur minimal. Écris superviser(code, essais) qui lance un programme dans un processus fils et, s'il échoue (code ≠ 0), le relance jusqu'à essais fois, en affichant chaque tentative. Teste avec un programme qui échoue deux fois avant de réussir (utilise un fichier compteur temporaire pour mémoriser le nombre de tentatives).
✅ Pistes de correction
import os, subprocess, sys, tempfile
def superviser(code, essais):
for tentative in range(1, essais + 1):
r = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True)
print(f"tentative {tentative}: code={r.returncode}")
if r.returncode == 0:
return True
return False
with tempfile.TemporaryDirectory() as d:
compteur = os.path.join(d, "n.txt")
programme = f'''
import os
chemin = {compteur!r}
n = int(open(chemin).read()) if os.path.exists(chemin) else 0
open(chemin, "w").write(str(n + 1))
raise SystemExit(0 if n >= 2 else 1)
'''
print(superviser(programme, 5)) # réussit à la 3e tentative
C'est le principe des superviseurs de services (systemd, supervisord) : relancer un processus en échec, avec une limite pour éviter les boucles infinies.
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Confondre programme et processus | Un fichier n'est pas un processus | Programme = recette, processus = exécution |
| Oublier d'attendre les fils | Processus zombies, résultats perdus | wait / communicate / run |
| Ignorer le code de sortie | Une erreur passe inaperçue | Toujours tester returncode |
| Supposer que la mémoire est partagée | Le fils ne modifie pas le parent | Utiliser tubes, fichiers ou sockets |
🐉 Mini-boss (40 XP)
Pool de travailleurs. Écris executer_en_parallele(taches, max_simultanes) : taches est une liste de petits programmes Python (chaînes). La fonction les lance dans des processus séparés, au plus max_simultanes à la fois, et renvoie la liste des résultats (code, sortie) dans l'ordre des tâches.
Teste avec 6 tâches de 0,2 s et max_simultanes = 1, 2, 6. Mesure le temps total et explique le résultat.
✅ Pistes de correction
import subprocess, sys, time
def executer_en_parallele(taches, max_simultanes):
resultats = [None] * len(taches)
en_cours = {} # index -> Popen
suivant = 0
while suivant < len(taches) or en_cours:
while suivant < len(taches) and len(en_cours) < max_simultanes:
en_cours[suivant] = subprocess.Popen([sys.executable, "-c", taches[suivant]],
stdout=subprocess.PIPE, text=True)
suivant += 1
for i, p in list(en_cours.items()):
if p.poll() is not None:
sortie = p.stdout.read().strip()
resultats[i] = (p.returncode, sortie)
del en_cours[i]
time.sleep(0.01)
return resultats
taches = [f"import time; time.sleep(0.2); print({i})" for i in range(6)]
for m in (1, 2, 6):
t = time.perf_counter()
r = executer_en_parallele(taches, m)
print(m, (time.perf_counter() - t, ), , [x[] x r])
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un processus est :
- A. un fichier exécutable
- B. un type de mémoire
- C. un programme en cours d'exécution
2. Un code de sortie 0 signifie généralement :
- A. succès
- B. erreur
- C. attente
3. Deux processus partagent par défaut :
- A. toute leur mémoire
- B. rien de leur mémoire
- C. leur pile
4. 🔁 Révision mission 01 : Un appel système permet :
- A. d'éteindre l'ordinateur
- B. d'écrire du code plus vite
- C. à un programme de demander un service au noyau
5. 🔁 Révision HEF-040, mission 09 : La loi d'Amdahl dit que l'accélération est limitée par :
- A. la partie non parallélisable
- B. la fréquence
- C. la taille de la RAM
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quel processus de ta vie quotidienne a un « parent » (une tâche qui en déclenche d'autres) ?
- Pourquoi l'isolation entre processus est-elle une protection précieuse ?
🎒 À retenir
- Programme = fichier ; processus = exécution avec PID et mémoire propres.
- États : prêt, en cours, bloqué, terminé.
- Parent/enfant ; PID 1 est le premier processus.
- Code de sortie : 0 = succès.
- Zombie : enfant terminé non « récolté » ; orphelin : adopté par init.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Chef de processus
← Mission 01 — Le rôle d'un système d'exploitation · Mission 03 — Threads et concurrence →
HEF-050 — Systèmes d'exploitation

