Cours sur les Threads (Processus légers) –
Explication pour Débutants
1. Qu’est-ce qu’un processus ?
Un processus est un programme en cours d’exécution. Quand tu ouvres un logiciel (Word, Terminal, etc.),
le système d’exploitation crée un processus.
Chaque processus a sa propre mémoire, ses variables, et ses fichiers ouverts. Les processus sont
indépendants les uns des autres.
2. Le problème des processus
Créer un processus est lourd : il faut copier beaucoup de mémoire et passer par le système pour
communiquer avec d’autres processus.
C’est lent et consomme beaucoup de ressources. D’où la création des threads.
3. Qu’est-ce qu’un Thread ?
Un thread (ou processus léger) est une sous-tâche d’un processus. Tous les threads d’un même
processus partagent la même mémoire.
Ils permettent de faire plusieurs actions en parallèle dans le même programme.
Exemple :
Dans Microsoft Word :
- un thread gère le clavier,
- un autre sauvegarde automatiquement,
- un autre corrige l’orthographe,
- un autre affiche le texte à l’écran.
4. Ressources partagées et séparées
Chaque thread a :
• Ses propres variables locales et pile d’exécution.
• Mais partage le code, les variables globales et les fichiers ouverts avec les autres threads.
5. Avantages des Threads
• Plus rapides à créer qu’un processus complet.
• Partage facile de données.
• Réduction de la mémoire utilisée.
• Meilleure réactivité : un thread continue même si un autre attend.
6. Types de threads
• Threads utilisateur : gérés par une bibliothèque (comme pthread).
• Threads noyau : gérés directement par le système d’exploitation.
7. Les threads POSIX (pthread) sous Linux
La bibliothèque permet de créer et gérer des threads en langage C.
Principales fonctions :
- pthread_create() : crée un thread
- pthread_join() : attend la fin d’un thread
- pthread_exit() : termine un thread
8. Application 1 – Le gâteau ■
Un gâteau de 8 parts. 4 threads mangent une part chaque seconde. Quand il n’y a plus de parts, chaque
thread affiche :
‘thread X : Gâteau terminé !!!’.
Le père attend la fin de tous ses threads.
Code C :
#include
#include
#include
volatile int nbr_parts_gateaux = 8;
void* manger(void* args) {
while (nbr_parts_gateaux > 0) {
nbr_parts_gateaux--;
printf("thread %d : nombre de parts restants = %d\n", (int)(long)args, nbr_parts_gateaux);
sleep(1);
}
printf("thread %d : Gâteau terminé\n", (int)(long)args);
return 0;
}
int main() {
pthread_t tab[4];
int i;
for (i = 0; i < 4; i++)
pthread_create(&tab;[i], NULL, manger, (void*)(long)i);
for (i = 0; i < 4; i++)
pthread_join(tab[i], NULL);
return 0;
}
9. Application 2 – Le réservoir d’eau ■
Un réservoir contient 10 litres. Trois threads (pompes) retirent 1 litre toutes les 2 secondes.
Quand il n’y a plus d’eau, chaque pompe affiche : ‘Pompe X : Réservoir vide !!!’. Le père attend la fin des
threads.
Code C :
#include
#include
#include
volatile int litres_eau = 10;
void* pomper(void* args) {
while (litres_eau > 0) {
litres_eau--;
printf("Pompe %d : litres restants = %d\n", (int)(long)args, litres_eau);
sleep(2);
}
printf("Pompe %d : Réservoir vide !!!\n", (int)(long)args);
return 0;
}
int main() {
pthread_t pompe[3];
int i;
for (i = 0; i < 3; i++)
pthread_create(&pompe;[i], NULL, pomper, (void*)(long)i);
for (i = 0; i < 3; i++)
pthread_join(pompe[i], NULL);
return 0;
}
10. Résumé général
• Processus = programme en exécution.
• Thread = mini-tâche à l’intérieur d’un même programme.
• pthread_create() : crée un thread.
• pthread_join() : attend qu’il se termine.
• pthread_exit() : le termine proprement.
• volatile : garantit la lecture réelle en mémoire.