Aller au contenu

08 Les processus

🧭 Table des matières

1. Rappels de première

2. Les processus

3. Les processus sous Linux

4. Exercices

🎯 Compétences évaluables

  • Décrire la création et l’ordonnancement des processus par le système d’exploitation.
  • Identifier les risques d’interblocage (deadlock).

1. 🔹 Rappels de première

⚓︎

1.1. 🧠 Rôle du système d’exploitation

⚓︎

Le système d’exploitation (OS) est le véritable chef d’orchestre de l’ordinateur 🎼. Il gère toutes les ressources et fait le lien entre l’utilisateur, les programmes et le matériel.

⚙️ Fonctions principales de l’OS

  • 🧩 Gestion des ressources matérielles : l’OS cache la complexité du matériel, gère les interruptions, les entrées/sorties, évite les conflits et protège le système contre les usages impropres.
  • 📚 Bibliothèques et compatibilité : il fournit des bibliothèques pour simplifier la programmation et permettre à un même programme de tourner sur plusieurs machines compatibles.
  • 🚀 Exécution des programmes : il charge les programmes en mémoire et gère leur exécution simultanée. Ces programmes actifs sont appelés processus.
  • 🔐 Sécurité : il contrôle les accès, isole les utilisateurs et protège le système des erreurs ou intrusions.

💡 En résumé : l’OS est le cœur logiciel de la machine. Sans lui, aucune communication, aucun programme, aucune sécurité.

💻 1.2. Commandes Linux de base

⚓︎

Quelques commandes essentielles pour manipuler le système :

🧩 Commande 💬 Signification (anglais) 🧠 Rôle / Description
sudo substitute user do Exécute une commande avec les droits administrateur (mot de passe requis).
pwd print working directory Affiche le répertoire courant.
cd arg/ change directory Change de répertoire ; sans argument, revient au home.
ls arg list Liste le contenu d’un dossier.
ll ou ls -l long list Affiche des informations détaillées sur les fichiers.
ls -a list all Montre aussi les fichiers cachés.
chmod change mode Modifie les droits d’accès à un fichier/dossier.
mkdir make directory Crée un dossier.
rmdir remove directory Supprime un dossier vide.
rm remove Supprime un fichier.
rm -r remove recursively Supprime un dossier et tout son contenu.
mv arg1 arg2 move Renomme ou déplace un fichier.
touch arg touch Crée un fichier vide ou met à jour sa date de modification.
kill arg kill Stoppe le processus ayant le PID spécifié.

🔗 Tester ces commandes ici

2. ⚙️ Les processus

⚓︎

2.1. 📀 Notion de processus

⚓︎

Lorsqu’un programme est lancé, le système crée un ou plusieurs processus : 👉 une instance d’exécution du programme.

Un processus comprend :

  • 🔢 un ensemble d’instructions à exécuter ;
  • 🧮 l’état des registres du processeur ;
  • 💾 les ressources nécessaires (mémoire, ports, fichiers…).

💬 Différence essentielle :

  • Un programme = fichier statique d’instructions.
  • Un processus = exécution dynamique en cours de ce programme.

🧠 L’OS peut afficher et gérer ces processus à l’aide du gestionnaire de tâches ou d’outils comme ps sous Linux.

2.2. 🆔 Identification des processus

⚓︎

Chaque processus est identifié par un PID (Process IDentifier), un numéro unique. ➡️ Le premier processus (souvent init) possède le PID 1.

Chaque processus a aussi un PPID (Parent Process ID), identifiant du processus parent.

📊 Exemple :

  • PID = 1 → processus init
  • PPID = 0 → aucun parent (le premier processus du système)

🧩 Ainsi, tous les processus forment une arborescence hiérarchique.

2.3. 🧭 Ordonnancement des processus

⚓︎

Un système multitâche donne l’illusion que plusieurs programmes tournent en même temps. Mais ⚠️ un processeur ne traite qu’une instruction à la fois (sauf multi-cœurs).

C’est l’ordonnanceur (scheduler) qui décide quel processus passe à quel moment.

🎛️ Objectifs de l’ordonnanceur :

  • Choisir quel processus exécuter.
  • Déterminer combien de temps lui accorder.

🔄 Principaux algorithmes d’ordonnancement :

🧩 Modèle 🧠 Principe
FIFO / FCFS (First Come First Served) Le premier arrivé est le premier servi.
SJF (Shortest Job First) Le plus court processus est exécuté en premier.
Round Robin Chaque processus s’exécute à tour de rôle pendant un temps fixe (quantum de 20–30 ms).
Priorité Le processus ayant la priorité la plus élevée passe avant les autres.

🧮 Exemple : ordonnancement SJF

Explication du déroulement :

1️⃣ P1 arrive en premier → s’exécute immédiatement.

2️⃣ P2 arrive ensuite → s’exécute après P1.

3️⃣ P3, P4, P5 arrivent pendant l’exécution de P2.

4️⃣ L’algorithme choit le plus court (P5), puis P4, puis P3.

⏱️ Définitions utiles :

  • Temps d’arrivée (soumission) → moment où un processus entre dans la file.
  • Durée d’exécution → temps nécessaire pour son traitement complet.
  • Temps de terminaison → moment où le processus se termine réellement.

📘 Exemple :

  • Temps d’arrivée de P5 : 7
  • Durée de P5 : 1
  • Temps d’arrivée de P4 : 6
  • Durée de P4 : 2

🧠 Capytale : Activités

🧮 Activité n° 1 : temps de terminaison

Compléter la ligne « temps de terminaison » du tableau précédent.

Rappel utile :

  • Temps de terminaison d’un processus P = instant où P se termine (depuis t = 0).

  • On le lit directement sur le diagramme de Gantt (fin de la dernière tranche d’exécution de P).

❇️ Solution :

  • Méthode : repérer sur la frise temporelle l’instant où se termine chaque processus.

  • Notation : Tfin(P).

P1 P2 P3 P4 P5
Temps de terminaison 3 3+6 = 9 3+6+1+2+4 = 16 3+6+1+2 = 12 3+6+1 = 10
⏱️ Activité n° 2 : temps d’exécution (temps de séjour)

Compléter la ligne « temps d’exécution / temps de séjour » du tableau précédent.

Définition :

  • Temps de séjour (aussi appelé temps d’exécution dans ce contexte) :

\(T_{\text{séjour}}(P)\) = \(T_{\text{fin}}(P) - T_{\text{arrivée}}(P)\)

❇️ Solution :

  • Calcul : T_séjour(P) = Tfin(P) - Tarr(P).

  • Interprétation : durée totale passée dans le système (file d’attente + processeur).

P1 P2 P3 P4 P5
Temps d'exécution 3-0 = 3 9-1 = 8 16-4 = 12 12-6 = 6 10-7 = 3
🕓 Activité n° 3 : temps d’attente

Compléter la ligne « temps d’attente » du tableau précédent.

Définition :

  • Temps d’attente (dans la file, hors CPU) :

\(T_{\text{attente}}(P)\) = \(T_{\text{séjour}}(P) - \text{Durée}(P)\)

❇️ Solution :
  • Calcul en deux étapes :

1) T_séjour(P) = Tfin(P) - Tarr(P)

2) T_attente(P) = T_séjour(P) - Durée(P)

| | P1 | P2 | P3 | P4 | P5 |

|----------------|--------|--------|-----------|--------|--------| | Temps d'attente | 3-3 = 0 | 8-6 = 2 | 12-4 = 8 | 6-2 = 4 | 3-1 = 2 |

📋 Activité n° 4 : Ordonnancement FIFO ou FCFS

Compléter le tableau pour l’ordonnancement FIFO/FCFS et schématiser l’algorithme (diagramme de Gantt).

Processus P1 P2 P3 P4
Durée 3 2 4 3
Date d’arrivée 0 2 1 3
Temps d’attente
Temps d’exécution (séjour)

Rappel FIFO : on exécute les processus dans l’ordre d’arrivée (en cas d’égalité, on garde l’ordre d’apparition).

❇️ Solution : (FIFO/FCFS)

Ordre d’exécution (par arrivée) :

P1 (t=0) → P3 (arrivé à 1) → P2 (arrivé à 2) → P4 (arrivé à 3)

Gantt (en unités de temps)

|--P1--|------P3------|--P2--|---P4---|

0------3--------------7------9-------12

Temps de fin

  • P1 : 3

  • P3 : 7

  • P2 : 9

  • P4 : 12

Temps d’exécution (séjour) = Tfin − Tarr

  • P1 : 3 − 0 = 3

  • P3 : 7 − 1 = 6

  • P2 : 9 − 2 = 7

  • P4 : 12 − 3 = 9

Temps d’attente = Séjour − Durée

  • P1 : 3 − 3 = 0

  • P3 : 6 − 4 = 2

  • P2 : 7 − 2 = 5

  • P4 : 9 − 3 = 6

Tableau complété

Processus P1 P2 P3 P4
Durée 3 2 4 3
Date d’arrivée 0 2 1 3
Temps d’attente 0 5 2 6
Temps d’exécution (séjour) 3 7 6 9

Règle Round Robin (file FIFO) On maintient une file des prêts (ready queue).

  • Le processus en tête prend le CPU pendant min(q, temps restant).

  • S’il n’a pas fini : il retourne en fin de file.

  • Les nouveaux processus arrivent et sont ajoutés en fin de file dès qu’ils arrivent (au moment où on les “voit”, typiquement aux frontières d’unités de temps, et surtout au moment où le CPU se libère / qu’on choisit qui exécuter ensuite).

📋 Activité n° 5 : Ordonnancement Round Robin

Compléter le tableau pour l’ordonnancement Round Robin et schématiser l’algorithme.

👉 Préciser un quantum (ex. q = 2 unités de temps).

Processus P1 P2 P3 P4
Durée 3 2 4 3
Date d’arrivée 0 2 1 3
Temps d’attente
Temps d’exécution (séjour)

🔁 Rappel Round Robin :

Chaque processus actif reçoit le CPU pendant q unités ; s’il n’a pas terminé, il retourne en fin de file.

❇️ Solution :" (Round Robin, exemple avec q = 2)

Arrivées :

P1 @ 0 (3) P3 @ 1 (4) P2 @ 2 (2) P4 @ 3 (3)

À t = 0 Arrive : P1

➡️ File à t=0 : [P1, P1, P1]

À t=1, P3 arrive → il va en fin de file (mais P1 continue, on ne préempte pas au milieu du quantum)

➡️ File à t=1 : [P1, P1, P3, P3, P3, P3]

À t=2, fin de tranche de P1 :

  • P2 arrive juste à ce moment là File : [P1, P1, P3, P3, P3, P3, P2, P2]

  • P1 n’est pas fini → il retourne en fin de file

  • Ceux qui attendaient : P3 est déjà là

  • Nouvel arrivant : P2

  • Puis P1 qui revient en fin (car pas fini)

➡️ File à t=2 : [P3, P3, P3, P3, P2, P2, P1]

À t =3, P4 arrive → il est ajouté en fin de file (P3 continue jusqu’à t=4) juste à ce moment là File : [P3, P3, P3, P3, P2, P2, P1, P4, P4, P4]

P3 n’est pas fini → il retourne en fin de file

Puis P3 revient en fin

➡️ File à t=4 : [P2, P2, P1, P4, P4, P4, P3, P3]

À t = 4

P2 avait 2, il reste 0 → P2 termine à t=6

➡️ File à t=6 : [P1, P4, P4, P4, P3, P3]

À t = 6

CPU prend le premier : P1.

Attention : P1 a reste = 1, donc il ne prendra pas tout le quantum, il prend 1 unité seulement. P1 termine à t=7

➡️ File à t=7 : [P4, P4, P4, P3, P3]

À t = 7

CPU prend P4 de t=7 à t=9 (quantum 2)

CPU : 7→9 : P4 exécute 2 unités

P4 avait 3, il reste 1

P4 revient en fin

➡️ File à t=9 : [P3, P3, P4]

À t = 9

CPU prend P3 (reste 2) de t=9 à t=11

CPU : 9→11 : P3 exécute 2 unités

P3 termine à t=11

➡️ File à t=11 : [P4]

À t = 11

CPU prend P4 (reste 1) de t=11 à t=12

CPU : 11→12 : P4 exécute 1 unité

P4 termine à t=12

Gantt (q = 2)

  • t = 0 .. 2 : P1 (reste 1)

  • t = 2 .. 4 : P3 (reste 2)

  • t = 4 .. 6 : P2 (termine)

  • t = 6 .. 7 : P1 (termine)

  • t = 7 .. 9 : P4 (reste 1)

  • t = 9 .. 11 : P3 (termine)

  • t = 11 .. 12 : P4 (termine)

Temps de fin :

  • P2 : 6

  • P1 : 7

  • P3 : 11

  • P4 : 12

Temps d’exécution (séjour) = Tfin − Tarr :

  • P1 : 7 − 0 = 7

  • P2 : 6 − 2 = 4

  • P3 : 11 − 1 = 10

  • P4 : 12 − 3 = 9

Temps d’attente = Séjour − Durée :

  • P1 : 7 − 3 = 4

  • P2 : 4 − 2 = 2

  • P3 : 10 − 4 = 6

  • P4 : 9 − 3 = 6

✅ Tableau complété (q = 2)

Processus P1 P2 P3 P4
Durée 3 2 4 3
Date d’arrivée 0 2 1 3
Temps d’attente 4 2 6 6
Temps d’exécution (séjour) 7 4 10 9

ℹ️ Si votre quantum diffère, rejouez le Gantt (Le diagramme de Gantt représente la chronologie d’exécution des processus) avec votre valeur : les formules de séjour/attente restent identiques.

🧠 2.4. État des processus

⚓︎

Selon que l’ordonnanceur lui attribue ou non le processeur, un processus peut être :

  • ⚙️ Prêt : en attente d’être exécuté ;
  • 🚀 Élu : en cours d’exécution ;
  • ⏸️ Bloqué : en attente d’une ressource (E/S, fichier, saisie…), il repassera Prêt lorsque la ressource sera disponible.

📊 Diagrammes de transitions (source : info.blaisepascal.fr) :

image

Version simplifiée :

image

💬 Pourquoi un blocage ? Pendant l’exécution, le processus peut réclamer une ressource indisponible (ex. fichier déjà ouvert) ou attendre une entrée utilisateur. ➡️ Il passe alors en Bloqué, libérant le CPU pour d’autres. Quand la ressource arrive, il revient en Prêt, puis sera Élu à nouveau.

⚠️ 2.5. Notion d’interblocage (deadlock)

⚓︎

Un interblocage (deadlock) survient lorsque des processus se bloquent mutuellement en attendant des ressources détenues par l’autre.

💡 Exemple : deux processus A et B, deux ressources R et S :

image

Déroulement résumé : A prend R, B prend S, puis A attend S et B attend R → blocage mutuel.

🧩 Schéma « ressources / processus » : Cercles = processus, carrés = ressources :

image

On repère un cycle d’interdépendance → deadlock.

🧰 Prévenir / gérer un deadlock :⚓︎

  • 🔒 Prévention : déclarer à l’avance toutes les ressources nécessaires.
  • 🧠 Évitement : maintenir un état du système garantissant une issue possible.
  • 🧹 Détection / résolution : laisser survenir puis briser le cycle (ex. forcer la libération d’une ressource).

🧱 Exemples concrets :⚓︎

carrefour

image

3. 🐧 Les processus sous Linux

⚓︎

3.1. 👀 Affichage des processus

⚓︎

💡 Pour obtenir de l’aide sur une commande Linux, utilisez :

Bash
man <commande>

Exemple :

Bash
man ps

Sous Linux, plusieurs commandes permettent de visualiser et analyser les processus en cours d’exécution.

🔗 MOOC Bash interactif – Université de La Réunion

🧩 Activité n° 6 : commande ps

1️⃣ Ouvrir un terminal. 2️⃣ Taper la commande :

Bash
ps -ef

Vous obtiendrez une liste détaillée des processus en cours (format complet) :

PID, PPID, utilisateur, état, commande, etc.

👉 Pour afficher uniquement certaines colonnes, utilisez :

Bash
ps -eo pid,ppid,stat,cmd

➜ permet de sélectionner précisément les colonnes affichées.

👉 Pour afficher l’arbre des processus, utilisez :

Bash
pstree -p

❇️ Solution : / Explications

  • ps : affiche un instantané (photo à un instant donné) des processus.

  • Options :

  • -e → affiche tous les processus

  • -f → affiche le format complet (informations détaillées)

  • Exemple ciblé :

    Bash
    ps -eo pid,ppid,stat,cmd
    ➜ affiche uniquement : PID, PPID, état, commande.

  • pstree -p : affiche les processus sous forme d’arborescence (relations père/fils) et ajoute les PID.

  • ⚠️ Remarque : selon la distribution, pstree peut nécessiter l’installation d’un paquet (souvent psmisc).

🧩 Activité n° 7 : commande top

1️⃣ Dans un terminal, taper la commande :

Bash
top

2️⃣ Pour quitter le mode interactif, appuyer sur q (ou Ctrl+C).

❇️ Solution : / Explications

  • top affiche en temps réel la liste des processus (mise à jour dynamique).
    Contrairement à ps, qui donne un état figé.

  • Cette commande permet de surveiller :

  • la charge CPU (%)
  • la mémoire utilisée

  • l’état des processus (R = running, S = sleeping, etc.)

  • Sur Linux, repères importants :

  • PID 1 : init ou le plus souvent systemd (ancêtre de la majorité des processus utilisateurs)
  • PID 2 : souvent kthreadd (ancêtre de nombreux threads/processus noyau)
  • PID 0 : tâche spéciale du noyau (idle task), pas un processus “classique”

3.2. 🧱 Interruption d’un processus

⚓︎

Un processus peut être interrompu ou supprimé à l’aide de la commande kill.

🧩 Commande :

Bash
kill <PID>

où <PID> correspond au numéro du processus à terminer.

📌 Par défaut, kill <PID> envoie le signal SIGTERM (15).

Lorsqu’un processus est "tué", il reçoit un signal de terminaison. Les plus courants sont :

🔢 Signal Nom Description
15 SIGTERM Demande polie de terminaison (libère proprement les ressources).
9 SIGKILL Interruption immédiate, brutale (ne laisse pas le processus se fermer proprement).
🧩 Activité n° 8 : commande kill (avec sleep)

🎯 Objectif : lancer un processus simple, récupérer son PID, puis l’arrêter avec un signal.

1️⃣ Lancer un processus “inoffensif” en arrière-plan :

Bash
sleep 1000 &

2️⃣ Récupérer son PID :

Bash
pgrep -a sleep

(Alternative si pgrep n’est pas disponible) :

Bash
ps -ef | grep sleep

3️⃣ Envoyer un signal de terminaison (SIGTERM par défaut) :

Bash
kill <PID>

4️⃣ Vérifier qu’il a disparu :

Bash
pgrep -a sleep
❇️ Solution : / Explications
  • sleep 1000 & lance un processus qui “attend” 1000 secondes, en arrière-plan.
  • pgrep -a sleep affiche les PID et les commandes correspondant à sleep.
  • kill <PID> envoie SIGTERM (15) : le processus se ferme proprement.
  • Si un processus refuse de s’arrêter (cas rares) :
    Bash
    kill -9 <PID>
    → SIGKILL (9) : arrêt immédiat, sans nettoyage (⚠️ à utiliser avec prudence).
  • ⚠️ Remarque : si vous n’avez pas les droits (processus d’un autre utilisateur), kill peut échouer.

3.3. 🧬 Création d’un processus

⚓︎

Sous Linux, la création d’un processus s’effectue via l’appel système fork(), qui duplique le processus existant.

  • 👨‍👦 Le processus père appelle fork().
  • 👶 Le processus fils est créé par clonage du père.
  • 🔁 Après duplication, chacun exécute son code indépendamment.

Le fils peut remplacer son programme par un autre grâce à exec(), qui charge un nouveau programme dans son espace mémoire.

💡 C’est le cœur du fonctionnement multitâche : lorsqu’on lance une commande, un nouveau processus est créé et s’exécute, généralement en tant que descendant de init / systemd (PID 1).

🧠 Capytale : Le code sera fourni par votre enseignant.

4. 🧠 Exercices

⚓︎

Exercice n°1 : Processus et interblocage

On considère trois processus P1, P2 et P3 décrits ci-dessous :

P1 : demande R1, demande R2, libère R1, libère R2 ;

P2 : demande R2, demande R3, libère R2, libère R3 ;

P3 : demande R3, demande R1, libère R3, libère R1.

Si les processus sont exécutés l’un après l’autre, d’abord P1, puis P2 et enfin P3, il n’y a pas de situation d’interblocage.

Décrire une exécution des trois processus qui conduit à une situation d’interblocage.

Dessiner un schéma représentant la situation.

Exercice n°2 : Processus

  1. Qu'est-ce qui limite concrètement le nombre de processus pouvant être lancer en même temps ?
  2. Qu'est-ce qu'un système d'exploitation multitâche ?
  3. Que va devoir faire un système d'exploitation multitâche lorsque plusieurs processus fonctionnent "en même temps" sur un ordinateur ne disposant que d'un seul microprocesseur (un coeur) ?
  4. Que se passe-t-il au démarrage de l'ordinateur ?
  5. Quels sont les états pendant lesquels la mémoire vive réserve de la place au processeur ?