Thread (informatique)

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Pour les articles homonymes, voir Thread et Fil.
Un processus avec deux threads.

Un thread ou fil (d'exécution) ou tâche (terme et définition normalisés par ISO/CEI 2382-7:2000 ; autres appellations connues : processus léger, unité de traitement, unité d'exécution, fil d'instruction, processus allégé, exétron[1]), est similaire à un processus car tous deux représentent l'exécution d'un ensemble d'instructions du langage machine d'un processeur. Du point de vue de l'utilisateur, ces exécutions semblent se dérouler en parallèle. Toutefois, là où chaque processus possède sa propre mémoire virtuelle, les threads d'un même processus se partagent sa mémoire virtuelle. Par contre, tous les threads possèdent leur propre pile d’appel.

Utilisation[modifier | modifier le code]

Les threads sont typiquement utilisés avec l'interface graphique (Graphical user interface) d'un programme ou par des programmes de calcul intensif (par exemple l'encodage d'une vidéo).

En effet, dans le cas d'une interface graphique, les interactions de l'utilisateur avec le processus, par l'intermédiaire des périphériques d'entrée, sont gérées par un thread, tandis que les calculs lourds (en termes de temps de calcul) sont gérés par un ou plusieurs autres threads. Cette technique de conception de logiciel est avantageuse dans ce cas, car l'utilisateur peut continuer d'interagir avec le programme même lorsque celui-ci est en train d'exécuter une tâche. Une application pratique se retrouve dans les traitements de texte où la correction orthographique est exécutée tout en permettant à l'utilisateur de continuer à entrer son texte. L'utilisation des threads permet donc de rendre l'utilisation d'une application plus fluide, car il n'y a plus de blocage durant les phases de traitements intenses.

Dans le cas d'un programme de calcul intensif, l'utilisation de plusieurs threads permet de paralléliser le traitement, ce qui, sur les machines multiprocesseur, permet de l'effectuer bien plus rapidement.

Threads et multitâche[modifier | modifier le code]

Les threads se distinguent du multi-processus plus classique par le fait que deux processus sont typiquement indépendants et peuvent interagir uniquement à travers une API fournie par le système telle que IPC. D'un autre côté les threads partagent une information sur l'état du processus, des zones de mémoires ainsi que d'autres ressources. Puisqu'il n'y a pas de changement de mémoire virtuelle, la commutation de contexte (context switch) entre deux threads est moins coûteuse que la commutation de contexte entre deux processus. On peut y voir un avantage de la programmation utilisant des threads multiples.

Avantages et inconvénients[modifier | modifier le code]

Dans certains cas, les programmes utilisant des threads sont plus rapides que des programmes architecturés plus classiquement, en particulier sur les machines comportant plusieurs processeurs. Hormis le problème du coût de la commutation de contexte, le principal surcoût dû à l'utilisation de processus multiples provient de la communication entre processus séparés. En effet, le partage de certaines ressources entre threads permet une communication plus efficace entre les différents threads d'un processus. Là où deux processus séparés doivent utiliser un mécanisme fourni par le système pour communiquer, les threads partagent une partie de l'état du processus.

La programmation utilisant des threads est toutefois plus difficile, et l'accès à certaines ressources partagées doit être restreint par le programme lui-même, pour éviter que l'état d'un processus ne devienne temporairement incohérent, tandis qu'un autre thread va avoir besoin de consulter cette portion de l'état du processus. Il est donc obligatoire de mettre en place des mécanismes de synchronisation (à l'aide de sémaphores par exemple), tout en conservant à l'esprit que l'utilisation de la synchronisation peut aboutir à des situations d'interblocage. La complexité des programmes utilisant des threads est aussi nettement plus grande que celle des programmes déférant le travail à faire à plusieurs processus plus simples. Cette complexité accrue, lorsqu'elle est mal gérée lors de la phase de conception ou de mise en œuvre d'un programme, peut conduire à de multiples problèmes.

Support des threads[modifier | modifier le code]

Les systèmes d'exploitation mettent en œuvre généralement les threads.

Certains langages de programmation, tels que Smalltalk et certaines implémentations de Java[2],[3],[4],[5], intègrent un support pour les threads implémentés dans l'espace utilisateur (green threads (en)), indépendamment des capacités du système d'exploitation hôte. La plupart des langages (Java sur la plupart des systèmes d'exploitation, C# .NET, C++, Ruby...) utilisent des extensions du langage ou des bibliothèques pour utiliser directement les services de multithreading du système d'exploitation, mais de façon portable (threads natifs). Enfin, des langages comme Haskell utilisent un système hybride à mi-chemin entre les deux approches. À noter que, pour des raisons de performances en fonction des besoins, la plupart des langages permettent d'utiliser au choix des threads natifs ou des green threads (notamment via l'utilisation de fibres).

En programmation orientée objet on parle de classe réentrante lorsque des instances distinctes d'une telle classe peuvent être utilisées par des threads sans créer de problèmes de concurrence. On parle de classe thread-safe lorsque plusieurs threads peuvent utiliser une même instance de cette classe sans en engendrer de problèmes de concurrence.

Dans un langage également orienté objet comme le C++, on y trouve depuis la nouvelle norme du C++, nommé C++11, une implémentation de la bibliothèque de threads de Boost. Le modèle de classe est le "std::thread", celui-ci est simple d'utilisation, et permet de bien créer et exécuter ses threads.

Patterns classiques avec les threads[modifier | modifier le code]

Il trois grands pattern fréquemment utilisés avec les threads :

  • Maitre/Esclave
    • Un thread centralise le travail à faire et le distribue aux esclaves
    • Pool d'esclaves statique ou dynamique
    • Ex : serveur web
  • Pipeline
    • La tâche est découpée en diverses étapes successives. Chaque thread réalise une étape et passe son résultat au suivant
    • Ex : traitement multimédia (streaming)
  • Peer to peer
    • Comme un maitre/esclaves, mais le maitre participe au travail

Confusion possible[modifier | modifier le code]

Il ne faut pas confondre la technologie Hyperthreading incluse dans certains processeurs Intel avec les threads. Cette technologie permet en effet aussi bien l'exécution simultanée de processus distincts que de threads. Toute machine comportant des processeurs multiples (SMP) ou des processeurs intégrant l'HyperThreading permet l'exécution plus rapide de programmes utilisant des threads aussi bien que des processus multiples.

Voir aussi[modifier | modifier le code]

Sur les autres projets Wikimedia :

Articles connexes[modifier | modifier le code]

Liens externes[modifier | modifier le code]

Références[modifier | modifier le code]

  1. Programmation Linux en pratique, Arnold Robbins, CampusPress Référence, ISBN 2-7440-1979-8, p. 54
  2. Matching the Thread Models Éléments sur le support des threads sur le site officiel Sun. (en)
  3. Programming Java threads in the real world Guide d'utilisation des threads sous Java sur le site JavaWorld. (en)
  4. Java Technology on the Linux Platform Annonce sur le site officiel Sun d'abandon des green threads sur Linux. (en)
  5. Java and Solaris threading Documentation officielle Sun sur le modèle de threading sur Solaris (en)