Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

ThreadPool classe

 

Date de publication : novembre 2016

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.

Espace de noms:   System.Threading
Assembly:  mscorlib (dans mscorlib.dll)

System.Object
  System.Threading.ThreadPool

[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public static class ThreadPool

NomDescription
System_CAPS_pubmethodSystem_CAPS_staticBindHandle(IntPtr)

Obsolète. Lie un handle de système d'exploitation à ThreadPool.

System_CAPS_pubmethodSystem_CAPS_staticBindHandle(SafeHandle)

Lie un handle de système d'exploitation à ThreadPool.

System_CAPS_pubmethodSystem_CAPS_staticGetAvailableThreads(Int32, Int32)

Récupère la différence entre le nombre maximal de threads du pool retourné par la méthode GetMaxThreads et le nombre actuel de threads actifs.

System_CAPS_pubmethodSystem_CAPS_staticGetMaxThreads(Int32, Int32)

Récupère le nombre de demandes au pool de threads pouvant être simultanément actives. Toutes les demandes excédant ce nombre restent dans la file d'attente jusqu'à ce que des threads du pool soient disponibles.

System_CAPS_pubmethodSystem_CAPS_staticGetMinThreads(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.

System_CAPS_pubmethodSystem_CAPS_staticQueueUserWorkItem(WaitCallback)

Place une méthode en file d'attente pour exécution. La méthode s'exécute lorsqu'un thread du pool devient disponible.

System_CAPS_pubmethodSystem_CAPS_staticQueueUserWorkItem(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. La méthode s'exécute lorsqu'un thread du pool devient disponible.

System_CAPS_pubmethodSystem_CAPS_staticRegisterWaitForSingleObject(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é.

System_CAPS_pubmethodSystem_CAPS_staticRegisterWaitForSingleObject(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é.

System_CAPS_pubmethodSystem_CAPS_staticRegisterWaitForSingleObject(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.

System_CAPS_pubmethodSystem_CAPS_staticRegisterWaitForSingleObject(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é.

System_CAPS_pubmethodSystem_CAPS_staticSetMaxThreads(Int32, Int32)

Définit le nombre de demandes au pool de threads pouvant être simultanément actives. Toutes les demandes excédant ce nombre restent dans la file d'attente jusqu'à ce que des threads du pool soient disponibles.

System_CAPS_pubmethodSystem_CAPS_staticSetMinThreads(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.

System_CAPS_pubmethodSystem_CAPS_staticUnsafeQueueNativeOverlapped(NativeOverlapped*)

Met en file d'attente l'exécution d'une opération d'E/S avec chevauchement.

System_CAPS_pubmethodSystem_CAPS_staticUnsafeQueueUserWorkItem(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.

System_CAPS_pubmethodSystem_CAPS_staticUnsafeRegisterWaitForSingleObject(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. Cette méthode ne propage pas la pile appelante vers le thread de travail.

System_CAPS_pubmethodSystem_CAPS_staticUnsafeRegisterWaitForSingleObject(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é. Cette méthode ne propage pas la pile appelante vers le thread de travail.

System_CAPS_pubmethodSystem_CAPS_staticUnsafeRegisterWaitForSingleObject(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.

System_CAPS_pubmethodSystem_CAPS_staticUnsafeRegisterWaitForSingleObject(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é. Cette méthode ne propage pas la pile appelante vers le thread de travail.

Many applications create threads that spend a great deal of time in the sleeping state, waiting for an event to occur. Other threads might enter a sleeping state only to be awakened periodically to poll for a change or update status information. 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. Examples of operations that use thread pool threads include the following:

  • When you create a T:System.Threading.Tasks.Task or T:System.Threading.Tasks.Task`1 object to perform some task asynchronously, by default the task is scheduled to run on a thread pool thread.

  • Asynchronous timers use the thread pool. Thread pool threads execute callbacks from the T:System.Threading.Timer class and raise events from the T:System.Timers.Timer class.

  • When you use registered wait handles, a system thread monitors the status of the wait handles. When a wait operation completes, a worker thread from the thread pool executes the corresponding callback function.

  • When you call the M:System.Threading.ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback) method to queue a method for execution on a thread pool thread. You do this by passing the method a T:System.Threading.WaitCallback delegate. The delegate has the signature

    void WaitCallback(Object state)
    

    where state is an object that contains data to be used by the delegate. The actual data can be passed to the delegate by calling the M:System.Threading.ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback,System.Object) method.

System_CAPS_noteRemarque

The threads in the managed thread pool are background threads. That is, their P:System.Threading.Thread.IsBackground properties are true. This means that a T:System.Threading.ThreadPool thread will not keep an application running after all foreground threads have exited.

System_CAPS_importantImportant

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 T:System.ThreadStaticAttribute attribute. Therefore, when a method examines thread local storage or fields that are marked with the T:System.ThreadStaticAttribute attribute, the values it finds might be left over from an earlier use of the thread pool thread.

You can also queue work items that are not related to a wait operation to the thread pool. To request that a work item be handled by a thread in the thread pool, call the M:System.Threading.ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback,System.Object) method. 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. There is no way to cancel a work item after it has been queued.

Timer-queue timers and registered wait operations also use the thread pool. Their callback functions are queued to the thread pool.

There is one thread pool per process. Beginning with the net_v40_long, the default size of the thread pool for a process depends on several factors, such as the size of the virtual address space. A process can call the M:System.Threading.ThreadPool.GetMaxThreads(System.Int32@,System.Int32@) method to determine the number of threads. The number of threads in the thread pool can be changed by using the M:System.Threading.ThreadPool.SetMaxThreads(System.Int32,System.Int32) method. Each thread uses the default stack size and runs at the default priority.

System_CAPS_noteRemarque

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.

The thread pool provides new worker threads or I/O completion threads on demand until it reaches the minimum for each category. When a minimum is reached, the thread pool can create additional threads in that category or wait until some tasks complete. Beginning with the net_v40_short, 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. Too few threads might not make optimal use of available resources, whereas too many threads could increase resource contention.

System_CAPS_noteRemarque

When demand is low, the actual number of thread pool threads can fall below the minimum values.

You can use the M:System.Threading.ThreadPool.GetMinThreads(System.Int32@,System.Int32@) method to obtain these minimum values.

System_CAPS_cautionAttention

You can use the M:System.Threading.ThreadPool.SetMinThreads(System.Int32,System.Int32) method to increase the minimum number of threads. However, unnecessarily increasing these values can cause performance problems. If too many tasks start at the same time, all of them might appear to be slow. In most cases the thread pool will perform better with its own algorithm for allocating threads.

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. The ThreadProc method simply displays a message.

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.

If you comment out the call to the M:System.Threading.Thread.Sleep(System.Int32) method, the main thread exits before method runs on the thread pool thread. The thread pool uses background threads, which do not keep the application running if all foreground threads have terminated. (This is a simple example of a race condition.)

.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0

This type is thread safe.

Retour au début
Afficher: