Comprendre les pools de threads en C #

Un thread est la plus petite unité d'exécution d'un processus. Un pool de threads comprend un certain nombre de threads, ou une collection de threads pour être précis, et il peut être utilisé pour effectuer plusieurs activités en arrière-plan.

Pourquoi devrais-je utiliser des pools de threads?

Les threads sont chers car ils consomment beaucoup de ressources dans votre système pour l'initialisation, le changement de contexte et la libération des ressources qu'ils occupent. Normalement, lorsqu'un thread exécute une opération d'E / S (gestion de fichier, opération de base de données ou accès aux ressources réseau, etc.), le thread est bloqué par le système d'exploitation jusqu'à ce que l'opération d'E / S soit terminée. Le thread reprendra son fonctionnement CPU une fois son opération d'E / S terminée.

Un pool de threads est un bon choix lorsque vous souhaitez limiter le nombre de threads en cours d'exécution à un moment donné et que vous voulez éviter la surcharge liée à la création et à la destruction de threads dans votre application. C'est également un bon choix lorsque vous avez de nombreuses tâches dans votre application qui doivent être exécutées en parallèle ou simultanément et que vous souhaitez améliorer la réactivité de l'application en évitant les changements de contexte. Pour créer un pool de threads, vous pouvez tirer parti de la classe System.Threading.ThreadPool.

L'extrait de code suivant montre comment vous pouvez définir le nombre minimum de threads dans le pool de threads.

ThreadPool.SetMinThreads (50, 50);

Cependant, notez que lorsqu'une tâche de longue durée est en cours d'exécution, le thread du pool de threads peut être bloqué pendant une longue période. Pour aggraver les choses, les demandes entrantes qui dépendent des threads du pool de threads peuvent être en attente ou même être rejetées principalement parce que le pool de threads peut ne pas avoir de threads disponibles pour gérer une demande entrante. Un pool de threads n'est pas non plus un bon choix lorsque vous avez des threads qui diffèrent dans leurs priorités ou que vous devrez peut-être abandonner un thread prématurément. Une fin prématurée d'un thread implique que le thread a été arrêté de force avant la fin de son délai d'exécution.

Comment fonctionne un pool de threads?

En gros, lorsque vous travaillez avec des pools de threads, vous créez généralement une collection de threads et les stockez dans un pool de threads avant d'utiliser les threads dans votre application. Au fur et à mesure que vous avez besoin d'un thread, vous réutiliserez ces threads plutôt que de créer de nouveaux threads chaque fois que l'application a besoin d'utiliser un thread.

Ainsi, l'application ferait une demande au pool de threads pour obtenir un thread à partir de celui-ci, effectuerait des activités à l'aide du thread, puis renvoyer le thread au pool de threads une fois terminé. Les pools de threads sont utiles dans les situations où vous avez plus de tâches à exécuter que vous ne pouvez créer de threads (le nombre maximal de threads que vous pouvez créer par processus est limité) dans votre application.

Comment puis-je optimiser un pool de threads?

Lorsqu'un processus démarre, un pool de threads lui est alloué par le CLR. Notez que vous pouvez configurer la taille du pool de threads si vous en avez besoin. Le runtime gère le pool de threads de manière intelligente. Lorsque le pool de threads démarre, il n'y a qu'un seul thread dans le pool de threads. Dès lors, le gestionnaire de pool de threads (un composant responsable de la gestion du pool de threads) crée plus de threads et les stocke dans le pool de threads à mesure que la charge sur l'application augmente, c'est-à-dire que l'application a besoin de plus en plus de tâches à exécuter simultanément.

Le nombre de threads qui peuvent être disponibles dans le pool de threads à un moment donné est régi par la limite maximale autorisée de threads dans le pool de threads. En d'autres termes, le nombre de threads disponibles dans le pool de threads varie de temps en temps en fonction de la consommation de threads par l'application. Dès que la limite maximale (nombre maximum de threads dans le pool de threads) est atteinte, l'application crée de nouveaux threads beaucoup plus rarement.

Vous pouvez toujours définir vous-même la limite supérieure de threads autorisés dans le pool de threads. Pour ce faire, vous devez tirer parti de la propriété ThreadPool.SetMaxThreads. Pour définir la limite inférieure des threads dans le pool de threads, vous pouvez utiliser la propriété ThreadPool.SetMinThreads. La limite inférieure par défaut du nombre de threads dans le pool de threads est d'un thread par processeur.