Le pool de threads managésThe managed thread pool

La classe System.Threading.ThreadPool fournit à votre application un pool de threads de travail qui sont gérés par le système, ce qui vous permet de vous concentrer sur les tâches d’application plutôt que sur la gestion des threads.The System.Threading.ThreadPool class provides your application with a pool of worker threads that are managed by the system, allowing you to concentrate on application tasks rather than thread management. Si vous avez des tâches courtes qui nécessitent un traitement en arrière-plan, le pool de threads managés est un moyen simple de tirer parti de plusieurs threads.If you have short tasks that require background processing, the managed thread pool is an easy way to take advantage of multiple threads. L’utilisation du pool de threads est beaucoup plus facile dans Framework 4 et ultérieur, car vous pouvez créer des objets Task et Task<TResult> qui effectuent des tâches asynchrones sur les threads de pool.Use of the thread pool is significantly easier in Framework 4 and later, since you can create Task and Task<TResult> objects that perform asynchronous tasks on thread pool threads.

.NET utilise des threads de pool pour de nombreux scénarios, notamment les opérations de bibliothèque parallèle de tâches (TPL), l’achèvement des E/S asynchrones, les rappels de timer, les opérations d’attente inscrites, les appels de méthodes asynchrones utilisant des délégués et les connexions de sockets System.Net..NET uses thread pool threads for many purposes, including Task Parallel Library (TPL) operations, asynchronous I/O completion, timer callbacks, registered wait operations, asynchronous method calls using delegates, and System.Net socket connections.

Caractéristiques du pool de threadsThread pool characteristics

Les threads de pool sont des threads d’arrière-plan.Thread pool threads are background threads. Chaque thread utilise la taille de pile par défaut, s'exécute avec la priorité par défaut et se trouve dans le multithread cloisonné.Each thread uses the default stack size, runs at the default priority, and is in the multithreaded apartment. Une fois qu’un thread du pool de threads a terminé sa tâche, il est retourné à une file d’attente de threads en attente.Once a thread in the thread pool completes its task, it's returned to a queue of waiting threads. À partir de ce moment, il peut être réutilisé.From this moment it can be reused. Cette réutilisation permet aux applications d’éviter le coût lié à la création d’un nouveau thread pour chaque tâche.This reuse enables applications to avoid the cost of creating a new thread for each task.

Il n'y a qu'un seul pool de threads par processus.There is only one thread pool per process.

Exceptions dans les threads de poolExceptions in thread pool threads

Les exceptions non gérées dans les threads de pool entraînent la fin du processus.Unhandled exceptions in thread pool threads terminate the process. Il existe trois exceptions à cette règle :There are three exceptions to this rule:

Pour plus d'informations, voir Exceptions dans les threads managés.For more information, see Exceptions in Managed Threads.

Nombre maximal de threads dans un poolMaximum number of thread pool threads

Le nombre d’opérations qui peuvent être mises en file d’attente pour le pool de threads est limité seulement par la mémoire disponible.The number of operations that can be queued to the thread pool is limited only by available memory. Cependant, le pool de threads limite le nombre de threads qui peuvent être actifs simultanément dans le processus.However, the thread pool limits the number of threads that can be active in the process simultaneously. Si tous les threads du pool sont occupés, les éléments de travail supplémentaires sont mis en file d’attente jusqu’à ce que des threads soient disponibles pour les exécuter.If all thread pool threads are busy, additional work items are queued until threads to execute them become available. À compter du .NET Framework 4, la taille par défaut du pool de threads pour un processus dépend de plusieurs facteurs, comme la taille de l’espace d’adressage virtuel.Beginning with the .NET Framework 4, the default size of the thread pool for a process depends on several factors, such as the size of the virtual address space. Un processus peut appeler la méthode ThreadPool.GetMaxThreads pour déterminer le nombre de threads.A process can call the ThreadPool.GetMaxThreads method to determine the number of threads.

Vous pouvez contrôler le nombre maximal de threads à l'aide des méthodes ThreadPool.GetMaxThreads et ThreadPool.SetMaxThreads.You can control the maximum number of threads by using the ThreadPool.GetMaxThreads and ThreadPool.SetMaxThreads methods.

Notes

Le code qui héberge le Common Language Runtime peut définir la taille avec la méthode ICorThreadpool::CorSetMaxThreads.Code that hosts the common language runtime can set the size using the ICorThreadpool::CorSetMaxThreads method.

Valeurs minimales d’un pool de threadsThread pool minimums

Le pool de threads fournit de nouveaux threads de travail ou des threads de terminaison d'E/S à la demande jusqu'à ce qu'il atteigne la valeur minimale spécifiée pour chaque catégorie.The thread pool provides new worker threads or I/O completion threads on demand until it reaches a specified minimum for each category. Vous pouvez utiliser la méthode ThreadPool.GetMinThreads pour obtenir ces valeurs minimales.You can use the ThreadPool.GetMinThreads method to obtain these minimum values.

Notes

Quand la demande est faible, le nombre réel de threads du pool peut être inférieur aux valeurs minimales.When demand is low, the actual number of thread pool threads can fall below the minimum values.

Quand une valeur minimale est atteinte, le pool de threads peut créer des threads supplémentaires ou attendre que certaines tâches soient terminées.When a minimum is reached, the thread pool can create additional threads or wait until some tasks complete. À compter du .NET Framework 4, le pool de threads crée et détruit des threads de travail pour optimiser le débit, qui est défini comme étant le nombre de tâches exécutées par unité de temps.Beginning with the .NET Framework 4, the thread pool creates and destroys worker threads in order to optimize throughput, which is defined as the number of tasks that complete per unit of time. Un nombre trop bas de threads peut ne pas permettre une utilisation optimale des ressources disponibles, tandis qu'un nombre trop élevé de threads peut augmenter les conflits de ressources.Too few threads might not make optimal use of available resources, whereas too many threads could increase resource contention.

Attention

Vous pouvez utiliser la méthode ThreadPool.SetMinThreads pour augmenter le nombre minimal de threads inactifs.You can use the ThreadPool.SetMinThreads method to increase the minimum number of idle threads. Toutefois, une augmentation non nécessaire de ces valeurs peut entraîner des problèmes de performances.However, unnecessarily increasing these values can cause performance problems. Si vous démarrez trop de tâches en même temps, celles-ci seront lentes.If too many tasks start at the same time, all of them might appear to be slow. Dans la plupart des cas, le pool de threads sera plus performant avec son propre algorithme d'allocation de threads.In most cases the thread pool will perform better with its own algorithm for allocating threads.

Utilisation du pool de threadsUsing the thread pool

À compter du .NET Framework 4, le moyen le plus simple d’utiliser le pool de threads est d’utiliser la bibliothèque parallèle de tâches (TPL).Beginning with the .NET Framework 4, the easiest way to use the thread pool is to use the Task Parallel Library (TPL). Par défaut, les types de la bibliothèque parallèle de tâches, comme Task et Task<TResult>, utilisent des threads de pool pour exécuter des tâches.By default, TPL types like Task and Task<TResult> use thread pool threads to run tasks.

Vous pouvez également utiliser le pool de threads en appelant ThreadPool.QueueUserWorkItem depuis du code managé (ou ICorThreadpool::CorQueueUserWorkItem depuis du code non managé) et en passant un délégué System.Threading.WaitCallback représentant la méthode qui effectue la tâche.You can also use the thread pool by calling ThreadPool.QueueUserWorkItem from managed code (or ICorThreadpool::CorQueueUserWorkItem from unmanaged code) and passing a System.Threading.WaitCallback delegate representing the method that performs the task.

Une autre façon d’utiliser le pool de threads est de mettre en file d’attente des éléments de travail associés à une opération d’attente en utilisant la méthode ThreadPool.RegisterWaitForSingleObject et en passant un System.Threading.WaitHandle qui, quand il est signalé ou quand il a expiré, appelle la méthode représentée par le délégué System.Threading.WaitOrTimerCallback.Another way to use the thread pool is to queue work items that are related to a wait operation by using the ThreadPool.RegisterWaitForSingleObject method and passing a System.Threading.WaitHandle that, when signaled or when timed out, calls the method represented by the System.Threading.WaitOrTimerCallback delegate. Les threads de pool sont utilisés pour appeler les méthodes de rappel.Thread pool threads are used to invoke callback methods.

Pour obtenir des exemples, consultez les pages des API référencées.For the examples, check the referenced API pages.

Ignorer les vérifications de sécuritéSkipping security checks

Le pool de threads fournit également les méthodes ThreadPool.UnsafeQueueUserWorkItem et ThreadPool.UnsafeRegisterWaitForSingleObject.The thread pool also provides the ThreadPool.UnsafeQueueUserWorkItem and ThreadPool.UnsafeRegisterWaitForSingleObject methods. Ces méthodes ne doivent être utilisées que si vous êtes certain que la pile de l'appelant n'a pas fait l'objet de vérifications de sécurité effectuées pendant l'exécution de la tâche mise en file d'attente.Use these methods only when you are certain that the caller's stack is irrelevant to any security checks performed during the execution of the queued task. ThreadPool.QueueUserWorkItem et ThreadPool.RegisterWaitForSingleObject capturent la pile de l'appelant, qui est fusionnée avec la pile du thread de pool quand le thread commence à exécuter une tâche.ThreadPool.QueueUserWorkItem and ThreadPool.RegisterWaitForSingleObject both capture the caller's stack, which is merged into the stack of the thread pool thread when the thread begins to execute a task. Si une vérification de sécurité est requise, la pile entière doit être vérifiée.If a security check is required, the entire stack must be checked. Même si elle garantit une sécurité, cette vérification a un impact sur les performances.Although the check provides safety, it also has a performance cost.

Quand ne pas utiliser les threads de poolWhen not to use thread pool threads

Il existe plusieurs scénarios dans lesquels il est préférable de créer et de gérer vos propres threads au lieu d’utiliser des threads de pool :There are several scenarios in which it's appropriate to create and manage your own threads instead of using thread pool threads:

  • Si vous devez utiliser un thread de premier plan.You require a foreground thread.
  • Si un thread doit avoir une priorité particulière.You require a thread to have a particular priority.
  • Si vous avez des tâches qui entraînent le blocage du thread pendant une longue durée.You have tasks that cause the thread to block for long periods of time. Le pool de threads possède un nombre maximal de threads. Un grand nombre de threads de pool bloqués pourrait donc empêcher le démarrage des tâches.The thread pool has a maximum number of threads, so a large number of blocked thread pool threads might prevent tasks from starting.
  • Vous devez placer les threads dans un thread unique cloisonné.You need to place threads into a single-threaded apartment. Tous les threads ThreadPool se trouvent dans le multithread cloisonné.All ThreadPool threads are in the multithreaded apartment.
  • Vous avez besoin d'une identité stable associée au thread ou avez besoin de dédier un thread à une tâche.You need to have a stable identity associated with the thread, or to dedicate a thread to a task.

Voir aussiSee also