Utilisation de threads (Guide de programmation C#)
Mise à jour : novembre 2007
Par défaut, un programme C# a un thread. Ce thread exécute le code dans le programme de démarrage et de fin avec la méthode Main. Chaque commande exécutée par Main(soit directement soit indirectement) est effectuée par la valeur par défaut, ou thread principal, et ce thread se termine lorsque Main est retournée. Toutefois, les threads auxiliaires peuvent être créés et utilisés pour exécuter le code en parallèle avec le thread principal. Ces threads sont souvent appelés threads actifs.
Les threads de travail servent à exécuter des tâches longues ou critiques sans monopoliser le thread principal. Par exemple, les threads de travail sont souvent utilisés dans les applications serveur pour accomplir des requêtes entrantes sans attendre que la requête précédente soit terminée. Les threads servent également à effectuer des tâches « d'arrière-plan » dans les applications bureautiques afin que le thread principal (qui pilote les éléments de l'interface utilisateur) reste sensible aux actions de l'utilisateur.
Le multithreading résout les problèmes de débit et de sensibilité, mais il peut également introduire des problèmes de partage de ressources, tels que les blocages et conditions de concurrence critique. Les threads multiples sont plus adaptés aux tâches qui nécessitent des ressources différentes telles que les handles de fichiers ou les connexions réseau. Il est possible que l'assignation de plusieurs threads à une seule ressource engendre des problèmes de synchronisation. Le fait que des threads soient souvent bloqués lors de l'attente d'autres threads annule l'intérêt de l'utilisation de plusieurs threads.
Une stratégie courante consiste à utiliser des threads de travail pour effectuer des tâches longues ou critiques en termes de temps qui ne nécessitent pas beaucoup des ressources utilisées par d'autres threads. Naturellement, certaines des ressources de votre programme doivent être accessibles par plusieurs threads. Dans ces cas, l'espace de noms System.Threading fournit des classes pour synchroniser les threads. Ces classes sont notamment Mutex, Monitor, Interlocked et AutoResetEvent et ManualResetEvent.
Vous pouvez utiliser certaines ou toutes ces classes pour synchroniser les activités de plusieurs threads, mais le langage C# offre une certaine prise en charge pour le multi-threading. Par exemple, l'instruction lock C# fournit des fonctionnalités de synchronisation par le biais de l'utilisation implicite de Monitor.
Les rubriques suivantes illustrent des techniques de multithreading courantes :
Comment : créer et terminer des threads (Guide de programmation C#)
Comment : synchroniser un thread producteur et un thread consommateur (Guide de programmation C#)
Comment : utiliser un pool de threads (Guide de programmation C#)
Rubriques connexes
Pour plus d'informations, consultez :
Voir aussi
Tâches
Synchronisation de moniteurs, exemple de technologie
Synchronisation d'attente, exemple de technologie