Processus et threads
Progression
#Processus et threads
Les processus et les threads constituent les deux abstractions fondamentales pour structurer l'exécution des programmes. Les processus offrent une isolation forte avec des espaces mémoire séparés, tandis que les threads permettent une exécution légère et parallèle au sein d'un même processus. Cette organisation permet de paralléliser les tâches et d'améliorer la réactivité des applications, le noyau du système d'exploitation se chargeant de planifier leur exécution et de gérer l'accès aux ressources partagées.
#Processus vs threads
Les processus représentent des programmes en cours d'exécution, chacun disposant de son propre espace mémoire isolé. Cette séparation offre une protection forte : un processus défaillant n'affecte pas directement les autres. À l'inverse, les threads sont des unités d'exécution plus légères qui partagent l'espace mémoire de leur processus parent. Ce partage les rend beaucoup plus rapides à créer et à gérer, mais impose une synchronisation explicite pour éviter les conflits d'accès aux données communes.
Cycle de vie des threads
Visualisez les transitions prêt/exécution/blocage pour différents profils de charge. Chaque jeton représente un thread concret.
Créé par le processus mais pas encore planifié
En file d’attente, attend un quantum CPU
Occupe un cœur CPU
Attend un événement externe ou un verrou
A libéré ses ressources
Création des threads
L’interface utilisateur (UI) vient d’être lancée, un worker I/O attend des requêtes disque, la tâche batch est en attente.
Le scheduler place UI devant pour respecter la réactivité.
- La priorité adaptative garde l’interface fluide sans affamer le batch.
- Le worker I/O retourne au pool après avoir signalé l’UI.
#Ordonnancement
L'ordonnanceur du système d'exploitation décide quel thread ou processus s'exécute sur chaque cœur de processeur et pour combien de temps. Les politiques d'ordonnancement se divisent en deux grandes familles : préemptives, où le système peut interrompre une tâche en cours, et coopératives, où les tâches cèdent volontairement le contrôle. Les algorithmes classiques incluent le tourniquet (Round-Robin) qui alterne équitablement entre les tâches, l'ordonnancement par priorité qui favorise les tâches critiques, et les files multi-niveaux qui combinent plusieurs stratégies. Les systèmes modernes exploitent également l'affinité CPU pour maintenir un thread sur le même cœur et bénéficier de la localité du cache.
#Synchronisation
Lorsque plusieurs threads accèdent à des données partagées, il est crucial de synchroniser leurs accès pour préserver la cohérence des données. Les primitives de synchronisation classiques incluent les mutex (exclusion mutuelle) qui garantissent qu'un seul thread accède à une ressource critique à la fois, les sémaphores qui contrôlent l'accès à un pool de ressources, et les barrières qui coordonnent des groupes de threads. Chaque section critique du code doit être protégée de manière à préserver les invariants des structures de données manipulées.
Exemple (pseudo‑code) d'une section critique protégée par mutex :
1mutex m;2int compteur = 0;3 4void travail() {5 lock(m);6 // section critique7 compteur += 1;8 unlock(m);9}Deadlocks si l'ordre d'acquisition diffère; inversion de priorité; ABA sur structures lock‑free. Définissez des ordres globaux et utilisez des primitives atomiques adaptées.
#Pièges
La programmation concurrente expose à plusieurs pièges classiques. Les deadlocks (interblocages) surviennent lorsque des threads s'attendent mutuellement de manière circulaire, paralysant l'ensemble. Les conditions de course apparaissent quand le résultat dépend de l'ordre d'exécution non déterministe des threads. L'inversion de priorité se produit lorsqu'un thread de faible priorité détenant un verrou bloque indirectement un thread de haute priorité. Ces problèmes requièrent une conception soigneuse des protocoles de synchronisation et le respect de disciplines strictes dans l'acquisition et la libération des verrous.