ThreadPool Classe

Définition

Fournit un pool de threads qui peuvent servir à exécuter des tâches, publier des éléments de travail, traiter des E/S asynchrones, attendre au nom d’autres threads et traiter des minuteries.Provides a pool of threads that can be used to execute tasks, post work items, process asynchronous I/O, wait on behalf of other threads, and process timers.

public ref class ThreadPool abstract sealed
public static class ThreadPool
type ThreadPool = class
Public Class ThreadPool
Héritage
ThreadPool

Exemples

Dans l’exemple suivant, le thread d’application principal met en file d’attente une méthode nommée ThreadProc pour s’exécuter sur un thread de pool de threads, se met en veille pendant une seconde, puis se ferme.In the following example, the main application thread queues a method named ThreadProc to execute on a thread pool thread, sleeps for one second, and then exits. La méthode ThreadProc affiche simplement un message.The ThreadProc method simply displays a message.

using namespace System;
using namespace System::Threading;

ref class Example
{
public:

   // This thread procedure performs the task.
   static void ThreadProc(Object^ stateInfo)
   {
      
      // No state object was passed to QueueUserWorkItem, so stateInfo is 0.
      Console::WriteLine( "Hello from the thread pool." );
   }
};

int main()
{
   // Queue the task.
   ThreadPool::QueueUserWorkItem(gcnew WaitCallback(Example::ThreadProc));

   Console::WriteLine("Main thread does some work, then sleeps.");
   
   Thread::Sleep(1000);
   Console::WriteLine("Main thread exits.");
   return 0;
}
// The example displays output like the following:
//       Main thread does some work, then sleeps.
//       Hello from the thread pool.
//       Main thread exits.
using System;
using System.Threading;

public class Example 
{
    public static void Main() 
    {
        // Queue the task.
        ThreadPool.QueueUserWorkItem(ThreadProc);
        Console.WriteLine("Main thread does some work, then sleeps.");
        Thread.Sleep(1000);

        Console.WriteLine("Main thread exits.");
    }

    // This thread procedure performs the task.
    static void ThreadProc(Object stateInfo) 
    {
        // No state object was passed to QueueUserWorkItem, so stateInfo is null.
        Console.WriteLine("Hello from the thread pool.");
    }
}
// The example displays output like the following:
//       Main thread does some work, then sleeps.
//       Hello from the thread pool.
//       Main thread exits.
Imports System.Threading

Public Module Example
    Public Sub Main()
        ' Queue the work for execution.
        ThreadPool.QueueUserWorkItem(AddressOf ThreadProc)
        
        Console.WriteLine("Main thread does some work, then sleeps.")

        Thread.Sleep(1000)

        Console.WriteLine("Main thread exits.")
    End Sub

    ' This thread procedure performs the task.
    Sub ThreadProc(stateInfo As Object)
        ' No state object was passed to QueueUserWorkItem, so stateInfo is null.
        Console.WriteLine("Hello from the thread pool.")
    End Sub
End Module
' The example displays output like the following:
'       Main thread does some work, then sleeps.
'       Hello from the thread pool.
'       Main thread exits.

Si vous commentez l’appel à la méthode Thread.Sleep, le thread principal se termine avant que la méthode s’exécute sur le thread du pool de threads.If you comment out the call to the Thread.Sleep method, the main thread exits before method runs on the thread pool thread. Le pool de threads utilise des threads d’arrière-plan, qui ne maintiennent pas l’exécution de l’application si tous les threads de premier plan ont été arrêtés.The thread pool uses background threads, which do not keep the application running if all foreground threads have terminated. (Il s’agit d’un exemple simple d’une condition de concurrence.)(This is a simple example of a race condition.)

Remarques

De nombreuses applications créent des threads qui consacrent beaucoup de temps à l’état de veille, en attendant qu’un événement se produise.Many applications create threads that spend a great deal of time in the sleeping state, waiting for an event to occur. D’autres threads peuvent entrer dans un état de veille uniquement pour être mis à jour régulièrement pour demander des informations sur l’état des modifications ou des mises à jour.Other threads might enter a sleeping state only to be awakened periodically to poll for a change or update status information. Le pool de threads vous permet d’utiliser les threads plus efficacement en fournissant à votre application un pool de threads de travail qui sont gérés par le système.The thread pool enables you to use threads more efficiently by providing your application with a pool of worker threads that are managed by the system. Voici quelques exemples d’opérations qui utilisent des threads de pool de threads :Examples of operations that use thread pool threads include the following:

  • Lorsque vous créez un objet Task ou Task<TResult> pour effectuer une tâche de manière asynchrone, par défaut, la tâche est planifiée pour s’exécuter sur un thread de pool de threads.When you create a Task or Task<TResult> object to perform some task asynchronously, by default the task is scheduled to run on a thread pool thread.

  • Les minuteries asynchrones utilisent le pool de threads.Asynchronous timers use the thread pool. Les threads de pool de threads exécutent des rappels à partir de la classe System.Threading.Timer et déclenchent des événements à partir de la classe System.Timers.Timer.Thread pool threads execute callbacks from the System.Threading.Timer class and raise events from the System.Timers.Timer class.

  • Lorsque vous utilisez des handles d’attente enregistrés, un thread système surveille l’état des handles d’attente.When you use registered wait handles, a system thread monitors the status of the wait handles. Quand une opération d’attente se termine, un thread de travail du pool de threads exécute la fonction de rappel correspondante.When a wait operation completes, a worker thread from the thread pool executes the corresponding callback function.

  • Lorsque vous appelez la méthode QueueUserWorkItem pour mettre en file d’attente une méthode en vue d’une exécution sur un thread de pool de threads.When you call the QueueUserWorkItem method to queue a method for execution on a thread pool thread. Pour ce faire, vous devez passer la méthode à un délégué WaitCallback.You do this by passing the method a WaitCallback delegate. Le délégué a la signatureThe delegate has the signature

    void WaitCallback(Object state)  
    
    Sub WaitCallback(state As Object)  
    

    state est un objet qui contient les données que le délégué doit utiliser.where state is an object that contains data to be used by the delegate. Les données réelles peuvent être passées au délégué en appelant la méthode QueueUserWorkItem(WaitCallback, Object).The actual data can be passed to the delegate by calling the QueueUserWorkItem(WaitCallback, Object) method.

Notes

Les threads dans le pool de threads managés sont des threads d’arrière-plan.The threads in the managed thread pool are background threads. Autrement dit, leurs propriétés IsBackground sont true.That is, their IsBackground properties are true. Cela signifie qu’un thread ThreadPool ne conservera pas une application en cours d’exécution après la sortie de tous les threads de premier plan.This means that a ThreadPool thread will not keep an application running after all foreground threads have exited.

Important

Lorsque le pool de threads réutilise un thread, il n’efface pas les données dans le stockage local des threads ni dans les champs marqués avec l’attribut ThreadStaticAttribute.When the thread pool reuses a thread, it does not clear the data in thread local storage or in fields that are marked with the ThreadStaticAttribute attribute. Par conséquent, lorsqu’une méthode examine le stockage local des threads ou les champs marqués avec l’attribut ThreadStaticAttribute, les valeurs qu’elle trouve peuvent être conservées à partir d’une utilisation antérieure du thread de pool de threads.Therefore, when a method examines thread local storage or fields that are marked with the ThreadStaticAttribute attribute, the values it finds might be left over from an earlier use of the thread pool thread.

Vous pouvez également mettre en file d’attente des éléments de travail qui ne sont pas associés à une opération d’attente dans le pool de threads.You can also queue work items that are not related to a wait operation to the thread pool. Pour demander qu’un élément de travail soit géré par un thread dans le pool de threads, appelez la méthode QueueUserWorkItem.To request that a work item be handled by a thread in the thread pool, call the QueueUserWorkItem method. Cette méthode prend comme paramètre une référence à la méthode ou au délégué qui sera appelé par le thread sélectionné à partir du pool de threads.This method takes as a parameter a reference to the method or delegate that will be called by the thread selected from the thread pool. Il n’existe aucun moyen d’annuler un élément de travail après qu’il a été mis en file d’attente.There is no way to cancel a work item after it has been queued.

Les minuteries de file d’attente et les opérations d’attente inscrites utilisent également le pool de threads.Timer-queue timers and registered wait operations also use the thread pool. Leurs fonctions de rappel sont mises en file d’attente dans le pool de threads.Their callback functions are queued to the thread pool.

Il existe un pool de threads par processus.There is one thread pool per process. Dans .NET Framework 4.NET Framework 4 et versions ultérieures, la taille par défaut du pool de threads d'un processus dépend de plusieurs facteurs, dont la taille de l'espace d'adressage virtuel.Beginning with the .NET Framework 4.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 GetMaxThreads pour déterminer le nombre de threads.A process can call the GetMaxThreads method to determine the number of threads. Le nombre de threads dans le pool de threads peut être modifié à l’aide de la méthode SetMaxThreads.The number of threads in the thread pool can be changed by using the SetMaxThreads method. Chaque thread utilise la taille de pile par défaut et s’exécute à la priorité par défaut.Each thread uses the default stack size and runs at the default priority.

Notes

Le code non managé qui héberge le .NET Framework peut modifier la taille du pool de threads à l’aide de la fonction CorSetMaxThreads, définie dans le fichier Mscoree. h.Unmanaged code that hosts the .NET Framework can change the size of the thread pool by using the CorSetMaxThreads function, defined in the mscoree.h file.

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 pour chaque catégorie.The thread pool provides new worker threads or I/O completion threads on demand until it reaches the minimum for each category. Quand un minimum est atteint, le pool de threads peut créer des threads supplémentaires dans cette catégorie ou attendre que certaines tâches se terminent.When a minimum is reached, the thread pool can create additional threads in that category or wait until some tasks complete. Dans .NET Framework 4.NET Framework 4 et versions ultérieures, le pool de threads crée et détruit des threads de travail pour optimiser le débit, qui est défini comme le nombre de tâches exécutées par unité de temps.Beginning with the .NET Framework 4.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.

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.

Vous pouvez utiliser la méthode GetMinThreads pour obtenir ces valeurs minimales.You can use the GetMinThreads method to obtain these minimum values.

Attention

Vous pouvez utiliser la méthode SetMinThreads pour augmenter le nombre minimal de threads.You can use the SetMinThreads method to increase the minimum number of 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.

Propriétés

CompletedWorkItemCount

Obtient le nombre d’éléments de travail qui ont été traités jusqu’à présent.Gets the number of work items that have been processed so far.

PendingWorkItemCount

Obtient le nombre d’éléments de travail qui sont actuellement en file d’attente pour être traités.Gets the number of work items that are currently queued to be processed.

ThreadCount

Obtient le nombre de threads du pool de threads qui existent actuellement.Gets the number of thread pool threads that currently exist.

Méthodes

BindHandle(IntPtr)

Lie un handle de système d'exploitation à ThreadPool.Binds an operating system handle to the ThreadPool.

BindHandle(SafeHandle)

Lie un handle de système d'exploitation à ThreadPool.Binds an operating system handle to the ThreadPool.

GetAvailableThreads(Int32, Int32)

Récupère la différence entre le nombre maximal de threads du pool retourné par la méthode GetMaxThreads(Int32, Int32) et le nombre actuel de threads actifs.Retrieves the difference between the maximum number of thread pool threads returned by the GetMaxThreads(Int32, Int32) method, and the number currently active.

GetMaxThreads(Int32, Int32)

Récupère le nombre de demandes au pool de threads pouvant être simultanément actives.Retrieves the number of requests to the thread pool that can be active concurrently. Toutes les demandes excédant ce nombre restent dans la file d'attente jusqu'à ce que des threads du pool soient disponibles.All requests above that number remain queued until thread pool threads become available.

GetMinThreads(Int32, Int32)

Récupère le nombre minimal de threads que le pool de threads crée à la demande, au fur et à mesure que de nouvelles requêtes sont effectuées, avant de basculer sur un algorithme pour la gestion de la création et de la suppression des threads.Retrieves the minimum number of threads the thread pool creates on demand, as new requests are made, before switching to an algorithm for managing thread creation and destruction.

QueueUserWorkItem(WaitCallback)

Place une méthode en file d'attente pour exécution.Queues a method for execution. La méthode s'exécute lorsqu'un thread du pool devient disponible.The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback, Object)

Place une méthode en file d'attente pour exécution et spécifie un objet contenant les données que la méthode doit utiliser.Queues a method for execution, and specifies an object containing data to be used by the method. La méthode s'exécute lorsqu'un thread du pool devient disponible.The method executes when a thread pool thread becomes available.

QueueUserWorkItem<TState>(Action<TState>, TState, Boolean)

Place en file d'attente une méthode spécifiée par un délégué Action<T> pour exécution et fournit les données que la méthode doit utiliser.Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. La méthode s'exécute lorsqu'un thread du pool devient disponible.The method executes when a thread pool thread becomes available.

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)

Inscrit un délégué pour attendre un WaitHandle, en utilisant, pour indiquer le délai en millisecondes, un entier 32 bits signé.Registers a delegate to wait for a WaitHandle, specifying a 32-bit signed integer for the time-out in milliseconds.

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)

Inscrit un délégué pour attendre un WaitHandle, en utilisant, pour indiquer le délai en millisecondes, un entier 64 bits signé.Registers a delegate to wait for a WaitHandle, specifying a 64-bit signed integer for the time-out in milliseconds.

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean)

Inscrit un délégué en attente de WaitHandle, en spécifiant une valeur TimeSpan pour indiquer le délai.Registers a delegate to wait for a WaitHandle, specifying a TimeSpan value for the time-out.

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean)

Inscrit un délégué pour attendre un WaitHandle, en utilisant, pour indiquer le délai en millisecondes, un entier 32 bits non signé.Registers a delegate to wait for a WaitHandle, specifying a 32-bit unsigned integer for the time-out in milliseconds.

SetMaxThreads(Int32, Int32)

Définit le nombre de demandes au pool de threads pouvant être simultanément actives.Sets the number of requests to the thread pool that can be active concurrently. Toutes les demandes excédant ce nombre restent dans la file d'attente jusqu'à ce que des threads du pool soient disponibles.All requests above that number remain queued until thread pool threads become available.

SetMinThreads(Int32, Int32)

Définit le nombre minimal de threads que le pool de threads crée à la demande, au fur et à mesure que de nouvelles requêtes sont effectuées, avant de basculer sur un algorithme pour la gestion de la création et de la suppression des threads.Sets the minimum number of threads the thread pool creates on demand, as new requests are made, before switching to an algorithm for managing thread creation and destruction.

UnsafeQueueNativeOverlapped(NativeOverlapped*)

Met en file d'attente l'exécution d'une opération d'E/S avec chevauchement.Queues an overlapped I/O operation for execution.

UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean)

Met en file d’attente l’objet élément de travail spécifié dans le pool de threads.Queues the specified work item object to the thread pool.

UnsafeQueueUserWorkItem(WaitCallback, Object)

Met le délégué spécifié en file d'attente dans le pool de threads, mais ne propage pas la pile d'appels vers le thread de travail.Queues the specified delegate to the thread pool, but does not propagate the calling stack to the worker thread.

UnsafeQueueUserWorkItem<TState>(Action<TState>, TState, Boolean)

Place en file d'attente une méthode spécifiée par un délégué Action<T> pour exécution et spécifie un objet contenant les données que la méthode doit utiliser.Queues a method specified by an Action<T> delegate for execution, and specifies an object containing data to be used by the method. La méthode s'exécute lorsqu'un thread du pool devient disponible.The method executes when a thread pool thread becomes available.

UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)

Inscrit un délégué pour attendre un WaitHandle, en utilisant, pour indiquer le délai en millisecondes, un entier signé 32 bits.Registers a delegate to wait for a WaitHandle, using a 32-bit signed integer for the time-out in milliseconds. Cette méthode ne propage pas la pile appelante vers le thread de travail.This method does not propagate the calling stack to the worker thread.

UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)

Inscrit un délégué pour attendre un WaitHandle, en utilisant, pour indiquer le délai en millisecondes, un entier 64 bits signé.Registers a delegate to wait for a WaitHandle, specifying a 64-bit signed integer for the time-out in milliseconds. Cette méthode ne propage pas la pile appelante vers le thread de travail.This method does not propagate the calling stack to the worker thread.

UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean)

Inscrit un délégué en attente de WaitHandle, en spécifiant une valeur TimeSpan pour indiquer le délai. Cette méthode ne propage pas la pile appelante vers le thread de travail.Registers a delegate to wait for a WaitHandle, specifying a TimeSpan value for the time-out. This method does not propagate the calling stack to the worker thread.

UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean)

Inscrit un délégué pour attendre un WaitHandle, en utilisant, pour indiquer le délai en millisecondes, un entier 32 bits non signé.Registers a delegate to wait for a WaitHandle, specifying a 32-bit unsigned integer for the time-out in milliseconds. Cette méthode ne propage pas la pile appelante vers le thread de travail.This method does not propagate the calling stack to the worker thread.

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi