Ficha de revisão: Gestion des processus et threads sous Linux

📋 Plan du Cours

1. Processus et contexte
2. États d'un processus
3. Processus sous Linux
4. Création et fin des processus
5. Attente et exec
6. Notion de thread
7. Gestion des threads sous Linux

📖 1. Processus et contexte

🔑 Notions clés & Définitions

• Contexte du processus : Le contexte du processus regroupe ses éléments qui déterminent son exécution, notamment le code/données/pile et l’état processeur avec ses registres.

📝 Points essentiels

• Un processus est un programme en cours d’exécution auquel on associe un environnement mémoire (code, données, pile) et un environnement processeur (CO, PSW, registres).
• Le processus passe par un contexte qui permet à l’ordonnanceur de le suspendre et de le reprendre plus tard.

💡 Astuce mémo

Mémoire + CPU = contexte du processus (ce que ça contient et ce que le processeur a à l’instant).

📖 2. États d'un processus

🔑 Notions clés & Définitions

• Prêt Ready : L’état prêt correspond à l’attente du processeur : le processus est en attente d’être élu par l’ordonnanceur.
• Élu Running : L’état élu signifie que le processus est actuellement exécuté par le processeur.
• Bloqué Stopped : L’état bloqué correspond à l’attente d’une ressource autre que le processeur, comme une opération d’E/S.

📝 Points essentiels

• Lors de l’exécution, un processus passe par Prêt, Élu et Bloqué.
• La transition 1 (élection) survient quand le processeur est libre et le premier processus prêt est choisi pour s’exécuter.
• La transition 2 (blocage) arrive quand, une fois élu, le processus demande une ressource et quitte le processeur pour passer bloqué.
• La transition 4 (réquisition) survient quand l’ordonnanceur retire le processeur à un processus pour le donner à un autre prêt (ex. fin de quatum).

💡 Astuce mémo

Élu → (demande ressource) Bloqué ; Prêt → (CPU libre) Élu ; Élu → (quatum fini) Prêt.

📖 3. Processus sous Linux

🔑 Notions clés & Définitions

• Processus 0 : Le processus 0 est créé lors du démarrage : il est lancé après le chargement d’une partie du système d’exploitation en RAM.
• init pid 1 : Le processus init correspond au processus de numéro de PID 1 créé par le processus 0.
• Démons pid 2 : Les démons correspondent aux processus de PID 2 créés par le processus 0 pendant le démarrage.

📝 Points essentiels

• Au démarrage, le bootstrap (ROM) charge une partie du système pour créer le processus 0.
• Le processus 0 crée init (PID 1) et des démons (PID 2), puis d’autres processus sont créés à partir d’init.
• Chaque processus a un père, et s’il perd son père il est adopté par le processus init.

💡 Astuce mémo

PID 0 lance PID 1 et PID 2, puis init orchestre le reste.

📖 4. Création et fin des processus

🔑 Notions clés & Définitions

• fork() : fork() crée un nouveau processus en dupliquant le code et les données du processus père.
• exit() : exit(int vstatus) termine volontairement l’exécution d’un processus via un arrêt volontaire avec un statut.

📝 Points essentiels

• fork() est exécutée par le processus père et retourne -1 en cas d’échec, 0 au processus fils, et un PID positif du fils au processus père.
• Un processus se termine soit par exit(int vstatus), soit par un arrêt forcé via le signal kill, soit par une erreur.
• Quand un fils se termine, son état de terminaison est enregistré dans son PCB, les ressources sont libérées, et le processus passe à l’état Zombie.
• Si un processus est tué par kill, ce signal est envoyé aussi à tous ses processus fils.

💡 Astuce mémo

fork sépare, exit clôt : père voit le PID du fils, fils reçoit 0.

📖 5. Attente et exec

🔑 Notions clés & Définitions

• wait() : wait(int *state) permet au père soit d’attendre la terminaison d’un fils, soit de vérifier si un fils est déjà terminé.
• waitpid : waitpid(p, state, 0) attend la terminaison soit de n’importe quel fils, soit d’un fils de PID p quand p est un entier > 0.
• exec : exec remplace le code exécutable d’un processus par un autre programme sans créer de nouveau processus.

📝 Points essentiels

• wait(state) bloque le processus appelant jusqu’à ce qu’au moins un fils se termine, puis rend le PID du fils terminé en code retour.
• Dès que le père prend connaissance de la mort du fils, il détruit le PCB du fils.
• waitpid(p, state, 0) avec p>0 bloque jusqu’à ce que le fils de PID p soit terminé.
• Linux propose une famille d’appels exec (avec la bibliothèque <sys/types.h>) pour remplacer le code par un programme spécifié par Path ou File, avec recouvrement mémoire plutôt que création d’un nouveau processus.
• En cas de succès de exec, l’ancien code est remplacé et n’exécute pas les instructions suivantes, alors qu’en cas d’échec l’exécution continue à l’instruction qui suit l’appel.

💡 Astuce mémo

wait = attendre la mort d’un fils ; exec = remplacer son programme sans recréer un PID.

📖 6. Notion de thread

🔑 Notions clés & Définitions

• Thread principal : Le thread principal est le fil d’exécution créé au démarrage du processus, correspondant à l’exécution du main.
• Fil d’exécution : Un fil d’exécution est l’unité d’exécution du processus, associée à l’exécution du code par un thread.
• Processus multithread : Un processus multithread exécute plusieurs threads en concurrence, sous l’action du processus lourd.

📝 Points essentiels

• En C, chaque processus commence par exécuter main, aussi appelé thread principal.
• Un thread exécute une partie du processus, généralement une fonction, et s’exécute en concurrence avec le processus lourd.
• Dans un processus multithread, les threads partagent et s’appuient sur les ressources du processus, tout en ayant chacun leur propre pile et registres au moment de l’exécution.

💡 Astuce mémo

main lance le thread principal ; plusieurs piles = plusieurs threads dans le même processus.

📖 7. Gestion des threads sous Linux

🔑 Notions clés & Définitions

• pthread_create : pthread_create crée un thread qui exécute une fonction fournie avec un argument, en utilisant des attributs éventuellement par défaut.
• pthread_join : pthread_join attend la fin d’un thread en récupérant son statut, en précisant le tid du thread à attendre.
• pthread_exit : pthread_exit termine un thread en renvoyant une valeur d’état (argument) au mécanisme de terminaison.

📝 Points essentiels

• pthread_create(tid, attr, nomFonction, arg) crée un thread et exécute nomFonction avec arg, et NULL pour attr signifie valeurs par défaut.
• pthread_join(tid, status) attend la fin d’un thread et joue un rôle analogue à waitpid côté processus, mais avec un tid de thread.
• pthread_exit(valeur_de_retour) arrête l’exécution du thread en retournant une valeur de terminaison.
• Dans l’exemple, le thread créé exécute presentation puis appelle pthread_exit(NULL, tandis que le thread principal affiche son message après pthread_join.

💡 Astuce mémo

create pour démarrer, join pour attendre, exit pour quitter.

⚠️ Pièges & confusions fréquents

1. Confondre contexte mémoire (code/données/pile) et contexte processeur (CO, PSW, registres) : ils sont tous deux dans le contexte du processus.
2. Croire que la transition de blocage est due au fait que le processeur est retiré : en réalité le processus devient bloqué en demandant une ressource.
3. Mélanger fork() et exec() : fork() crée un nouveau processus (PID), tandis que exec() remplace le code sans créer de nouveau processus.
4. Interpréter le code de retour de fork() : le fils reçoit 0 et le père reçoit le PID positif du fils, tandis que -1 indique un échec.
5. Penser que wait ne bloque jamais : wait(state) bloque jusqu’à la terminaison d’un fils.
6. Se tromper sur l’attente de thread : pthread_join attend un tid de thread, et non un PID de processus.
7. Croire que pthread_exit termine tout le processus : pthread_exit termine l’exécution du thread courant, pas l’ensemble des threads.

✅ Checklist Examen

1. Définir un processus et citer les deux parties du contexte (mémoire et processeur).
2. Citer les trois états d’un processus (Prêt, Élu, Bloqué) et donner le sens de chacun.
3. Expliquer au moins deux transitions entre états en mentionnant la condition (élection quand CPU libre, réquisition en fin de quatum).
4. Décrire le rôle du processus 0 au démarrage et nommer ce qu’il crée (init PID 1 et démons PID 2).
5. Dire pourquoi chaque processus a un père et ce qui se passe si le père disparaît (adoption par init).
6. Rappeler le comportement de fork() : duplication code/données et cas de retour (-1, 0, PID positif au père).
7. Décrire les modes de terminaison d’un processus (exit, kill, erreur) et ce qui arrive au fils (PCB, libération ressources, état Zombie).
8. Expliquer wait() : blocage, destruction du PCB, et code retour égal au PID du fils terminé.
9. Préciser waitpid(p, state, 0) avec p>0 : blocage jusqu’à terminaison du fils de PID p.
10. Définir exec et distinguer succès vs échec : remplacement du code vs exécution après l’appel.
11. Donner la définition opérationnelle de thread : unité rattachée au processus exécutant une fonction en concurrence.
12. Relier thread principal à l’exécution de main dans un processus.
13. Décrire le triplet de primitives threads sous Linux : pthread_create (démarrage), pthread_join (attente), pthread_exit (terminaison du thread).