ThreadPool ThreadPool ThreadPool ThreadPool Class

Definizione

Fornisce un pool di thread che può essere usato per eseguire attività, inviare elementi di lavoro, elaborare operazioni di I/O asincrone, attendere per conto di altri thread ed elaborare timer.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
Ereditarietà
ThreadPoolThreadPoolThreadPoolThreadPool

Esempi

Nell'esempio seguente, il thread principale dell'applicazione Accoda un metodo denominato ThreadProc da eseguire in un pool di thread, viene sospeso per un secondo e quindi viene chiusa.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. Il ThreadProc metodo visualizza semplicemente un messaggio.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.

Se impostare come commento la chiamata al Thread.Sleep metodo, il thread principale viene chiuso prima di metodo viene eseguito nel pool di thread.If you comment out the call to the Thread.Sleep method, the main thread exits before method runs on the thread pool thread. Il pool di thread utilizza i thread in background, che non mantengono l'applicazione in esecuzione se tutti i thread in primo piano sono terminati.The thread pool uses background threads, which do not keep the application running if all foreground threads have terminated. (Questo è un esempio semplice di una race condition.)(This is a simple example of a race condition.)

Commenti

Molte applicazioni creano thread che spendono una notevole quantità di tempo nello stato inattivo, in attesa di un evento si verifichi.Many applications create threads that spend a great deal of time in the sleeping state, waiting for an event to occur. Altri thread potrebbero entrare in uno stato di solo a essere riattivati periodicamente per eseguire il polling di una modifica o aggiornare le informazioni sullo stato.Other threads might enter a sleeping state only to be awakened periodically to poll for a change or update status information. Il pool di thread consente di usare i thread in modo più efficiente fornendo all'applicazione con un pool di thread di lavoro gestiti dal sistema.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. Esempi di operazioni che usano i pool di thread includono quanto segue:Examples of operations that use thread pool threads include the following:

  • Quando si crea una Task o Task<TResult> oggetto effettui alcune attività in modo asincrono, per impostazione predefinita l'attività viene pianificata per l'esecuzione in un pool di thread.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.

  • Timer asincroni usano il pool di thread.Asynchronous timers use the thread pool. Eseguire le richiamate dal pool di thread di System.Threading.Timer classi e generare eventi dal System.Timers.Timer classe.Thread pool threads execute callbacks from the System.Threading.Timer class and raise events from the System.Timers.Timer class.

  • Quando si usano gli handle di attesa registrata, un thread di sistema consente di monitorare lo stato dell'handle di attesa.When you use registered wait handles, a system thread monitors the status of the wait handles. Quando viene completata un'operazione di attesa, un thread di lavoro dal pool di thread viene eseguita la funzione di callback corrispondente.When a wait operation completes, a worker thread from the thread pool executes the corresponding callback function.

  • Quando si chiama il QueueUserWorkItem metodo per accodare un metodo per l'esecuzione in un pool di thread.When you call the QueueUserWorkItem method to queue a method for execution on a thread pool thread. Eseguire questa operazione passando al metodo un WaitCallback delegare.You do this by passing the method a WaitCallback delegate. Il delegato ha la firmaThe delegate has the signature

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

    in cui state è un oggetto che contiene i dati da utilizzare dal delegato.where state is an object that contains data to be used by the delegate. I dati effettivi possono essere passati al delegato chiamando il QueueUserWorkItem(WaitCallback, Object) (metodo).The actual data can be passed to the delegate by calling the QueueUserWorkItem(WaitCallback, Object) method.

Nota

I thread nel pool di thread gestiti sono thread in background.The threads in the managed thread pool are background threads. Vale a dire loro IsBackground sono proprietà true.That is, their IsBackground properties are true. Ciò significa che un ThreadPool thread non manterrà un'applicazione in esecuzione dopo il termine di tutti i thread in primo piano.This means that a ThreadPool thread will not keep an application running after all foreground threads have exited.

Importante

Quando il pool di thread riusa un thread, non cancella i dati nell'archiviazione thread-local o nei campi contrassegnati con il ThreadStaticAttribute attributo.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. Pertanto, quando un metodo esamina l'archiviazione thread-local o i campi contrassegnati con il ThreadStaticAttribute attributo, i valori rilevati potrebbero essere rimasti un uso precedente del thread del pool.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.

È anche possibile accodare gli elementi di lavoro non correlati a un'operazione di attesa per il pool di thread.You can also queue work items that are not related to a wait operation to the thread pool. Per richiedere che un elemento di lavoro gestito da un thread nel pool di thread, chiamare il QueueUserWorkItem (metodo).To request that a work item be handled by a thread in the thread pool, call the QueueUserWorkItem method. Questo metodo accetta come parametro un riferimento al metodo o delegato che verrà chiamato dal thread selezionato dal pool di thread.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. Non è possibile annullare un elemento di lavoro dopo che è stata accodata.There is no way to cancel a work item after it has been queued.

I timer della coda del timer e le operazioni di attesa registrata anche usano il pool di thread.Timer-queue timers and registered wait operations also use the thread pool. Le funzioni di callback vengono accodate al pool di thread.Their callback functions are queued to the thread pool.

È un pool di thread per ogni processo.There is one thread pool per process. A partire da .NET Framework 4.NET Framework 4, la dimensione predefinita del pool di thread per un processo dipende da diversi fattori, ad esempio la dimensione dello spazio degli indirizzi virtuali.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 processo può chiamare il metodo GetMaxThreads per determinare il numero di thread.A process can call the GetMaxThreads method to determine the number of threads. Il numero di thread nel pool di thread può essere modificato tramite la SetMaxThreads (metodo).The number of threads in the thread pool can be changed by using the SetMaxThreads method. Ogni thread Usa la dimensione predefinita e viene eseguito con la priorità predefinita.Each thread uses the default stack size and runs at the default priority.

Nota

Il codice non gestito che ospita .NET Framework è possibile modificare le dimensioni del pool di thread usando il CorSetMaxThreads funzione, definito nel file di 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.

Il pool di thread fornisce nuovi thread di lavoro o thread di completamento i/o su richiesta fino a quando non raggiunge il valore minimo per ogni categoria.The thread pool provides new worker threads or I/O completion threads on demand until it reaches the minimum for each category. Quando viene raggiunto un valore minimo, il pool di thread può creare thread aggiuntivi in tale categoria o attendere fino al completamento di alcune attività.When a minimum is reached, the thread pool can create additional threads in that category or wait until some tasks complete. A partire da .NET Framework 4.NET Framework 4, il pool di thread crea ed elimina definitivamente i thread di lavoro per ottimizzare la velocità effettiva, definita come numero di attività completate per unità di tempo.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 numero troppo ridotto di thread potrebbe non usare in modo ottimale le risorse disponibili, mentre troppi thread potrebbero aumentare il conflitto per le risorse.Too few threads might not make optimal use of available resources, whereas too many threads could increase resource contention.

Nota

Quando la richiesta è bassa, il numero effettivo di thread del pool può scendere sotto i valori minimi.When demand is low, the actual number of thread pool threads can fall below the minimum values.

È possibile usare il metodo GetMinThreads per ottenere questi valori minimi.You can use the GetMinThreads method to obtain these minimum values.

Attenzione

È possibile usare il SetMinThreads metodo per aumentare il numero minimo di thread.You can use the SetMinThreads method to increase the minimum number of threads. Tuttavia, un aumento non necessario di questi valori può provocare problemi di prestazioni.However, unnecessarily increasing these values can cause performance problems. Se si avviano troppe attività contemporaneamente, potrebbero sembrare tutte lente.If too many tasks start at the same time, all of them might appear to be slow. Nella maggior parte dei casi, il pool di thread offre prestazioni migliori con il proprio algoritmo per l'allocazione dei thread.In most cases the thread pool will perform better with its own algorithm for allocating threads.

Metodi

BindHandle(IntPtr) BindHandle(IntPtr) BindHandle(IntPtr) BindHandle(IntPtr)

Associa un handle del sistema operativo al ThreadPool.Binds an operating system handle to the ThreadPool.

BindHandle(SafeHandle) BindHandle(SafeHandle) BindHandle(SafeHandle) BindHandle(SafeHandle)

Associa un handle del sistema operativo al ThreadPool.Binds an operating system handle to the ThreadPool.

GetAvailableThreads(Int32, Int32) GetAvailableThreads(Int32, Int32) GetAvailableThreads(Int32, Int32) GetAvailableThreads(Int32, Int32)

Recupera la differenza tra il numero massimo di thread del pool di thread restituito dal metodo GetMaxThreads(Int32, Int32) e il numero attualmente attivo.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) GetMaxThreads(Int32, Int32) GetMaxThreads(Int32, Int32) GetMaxThreads(Int32, Int32)

Recupera il numero di richieste al pool di thread che possono essere attive contemporaneamente.Retrieves the number of requests to the thread pool that can be active concurrently. Tutte le richieste al di fuori di tale numero rimangono in coda fino a quando non diventano disponibili thread di pool di thread.All requests above that number remain queued until thread pool threads become available.

GetMinThreads(Int32, Int32) GetMinThreads(Int32, Int32) GetMinThreads(Int32, Int32) GetMinThreads(Int32, Int32)

Recupera il numero minimo di thread che il pool di thread crea, man mano che vengono effettuate nuove richieste, prima di passare a un algoritmo per la gestione della creazione e dell'eliminazione del thread.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) QueueUserWorkItem(WaitCallback) QueueUserWorkItem(WaitCallback) QueueUserWorkItem(WaitCallback)

Accoda un metodo da eseguire.Queues a method for execution. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback, Object) QueueUserWorkItem(WaitCallback, Object) QueueUserWorkItem(WaitCallback, Object) QueueUserWorkItem(WaitCallback, Object)

Accoda un metodo da eseguire e specifica un oggetto che contiene i dati che dovranno essere usati dal metodo.Queues a method for execution, and specifies an object containing data to be used by the method. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.The method executes when a thread pool thread becomes available.

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

Accoda un metodo specificato da un delegato Action<T> per l'esecuzione e fornisce i dati che devono essere usati dal metodo.Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.The method executes when a thread pool thread becomes available.

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

Registra un delegato per l'attesa di un oggetto WaitHandle, specificando un intero senza segno a 32 bit per il timeout in millisecondi.Registers a delegate to wait for a WaitHandle, specifying a 32-bit unsigned integer for the time-out in milliseconds.

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

Registra un delegato per l'attesa di un oggetto WaitHandle, specificando un valore TimeSpan per il timeout.Registers a delegate to wait for a WaitHandle, specifying a TimeSpan value for the time-out.

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

Registra un delegato per l'attesa di un oggetto WaitHandle, specificando un valore intero con segno a 32 bit per il timeout in millisecondi.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) RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean) RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean) RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)

Registra un delegato per l'attesa di un oggetto WaitHandle, specificando un valore intero con segno a 64 bit per il timeout in millisecondi.Registers a delegate to wait for a WaitHandle, specifying a 64-bit signed integer for the time-out in milliseconds.

SetMaxThreads(Int32, Int32) SetMaxThreads(Int32, Int32) SetMaxThreads(Int32, Int32) SetMaxThreads(Int32, Int32)

Imposta il numero di richieste al pool di thread che possono essere attivate contemporaneamente.Sets the number of requests to the thread pool that can be active concurrently. Tutte le richieste al di fuori di tale numero rimangono in coda fino a quando non diventano disponibili thread di pool di thread.All requests above that number remain queued until thread pool threads become available.

SetMinThreads(Int32, Int32) SetMinThreads(Int32, Int32) SetMinThreads(Int32, Int32) SetMinThreads(Int32, Int32)

Imposta il numero minimo di thread che il pool di thread crea, man mano che vengono effettuate nuove richieste, prima di passare a un algoritmo per la gestione della creazione e dell'eliminazione del thread.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*) UnsafeQueueNativeOverlapped(NativeOverlapped*) UnsafeQueueNativeOverlapped(NativeOverlapped*) UnsafeQueueNativeOverlapped(NativeOverlapped*)

Accoda un'operazione di I/O sovrapposta per l'esecuzione.Queues an overlapped I/O operation for execution.

UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean) UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean) UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean) UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean)
UnsafeQueueUserWorkItem(WaitCallback, Object) UnsafeQueueUserWorkItem(WaitCallback, Object) UnsafeQueueUserWorkItem(WaitCallback, Object) UnsafeQueueUserWorkItem(WaitCallback, Object)

Accoda il delegato specificato al pool di thread, ma non propaga lo stack di chiamata nel thread di lavoro.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) UnsafeQueueUserWorkItem<TState>(Action<TState>, TState, Boolean) UnsafeQueueUserWorkItem<TState>(Action<TState>, TState, Boolean) UnsafeQueueUserWorkItem<TState>(Action<TState>, TState, Boolean)

Accoda un metodo specificato da un delegato Action<T> per l'esecuzione e specifica un oggetto che contiene i dati che dovranno essere usati dal metodo.Queues a method specified by an Action<T> delegate for execution, and specifies an object containing data to be used by the method. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.The method executes when a thread pool thread becomes available.

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

Registra un delegato per l'attesa di un oggetto WaitHandle, specificando un valore TimeSpan per il timeout. Questo metodo non propaga lo stack di chiamate al thread di lavoro.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, Int32, Boolean) UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean) UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean) UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)

Registra un delegato per l'attesa di un WaitHandle, specificando un intero con segno a 32 bit per il timeout in millisecondi.Registers a delegate to wait for a WaitHandle, using a 32-bit signed integer for the time-out in milliseconds. Questo metodo non propaga lo stack di chiamate al thread di lavoro.This method does not propagate the calling stack to the worker thread.

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

Registra un delegato per l'attesa di un oggetto WaitHandle, specificando un valore intero con segno a 64 bit per il timeout in millisecondi.Registers a delegate to wait for a WaitHandle, specifying a 64-bit signed integer for the time-out in milliseconds. Questo metodo non propaga lo stack di chiamate al thread di lavoro.This method does not propagate the calling stack to the worker thread.

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

Registra un delegato per l'attesa di un oggetto WaitHandle, specificando un intero senza segno a 32 bit per il timeout in millisecondi.Registers a delegate to wait for a WaitHandle, specifying a 32-bit unsigned integer for the time-out in milliseconds. Questo metodo non propaga lo stack di chiamate al thread di lavoro.This method does not propagate the calling stack to the worker thread.

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche