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 per l'esecuzione su un thread del pool di thread, viene letto per un secondo e quindi viene chiuso.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 metodo ThreadProc 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 si imposta come commento la chiamata al metodo Thread.Sleep, il thread principale viene chiuso prima dell'esecuzione del metodo nel thread del 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 usa 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. Si tratta di un semplice esempio di race condition.(This is a simple example of a race condition.)

Commenti

Molte applicazioni creano thread che impiegano molto tempo nello stato di sospensione, in attesa che si verifichi un evento.Many applications create threads that spend a great deal of time in the sleeping state, waiting for an event to occur. Gli altri thread potrebbero entrare in uno stato di sospensione solo per 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 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. Di seguito sono riportati alcuni esempi di operazioni che utilizzano i thread del pool di thread:Examples of operations that use thread pool threads include the following:

  • Quando si crea un oggetto Task o Task<TResult> per eseguire un'attività in modo asincrono, per impostazione predefinita l'attività è pianificata per l'esecuzione in un thread del 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.

  • I timer asincroni utilizzano il pool di thread.Asynchronous timers use the thread pool. I thread del pool di thread eseguono callback dalla classe System.Threading.Timer e generano eventi dalla classe System.Timers.Timer.Thread pool threads execute callbacks from the System.Threading.Timer class and raise events from the System.Timers.Timer class.

  • Quando si utilizzano gli handle di attesa registrati, un thread di sistema monitora lo stato degli handle di attesa.When you use registered wait handles, a system thread monitors the status of the wait handles. Al termine di un'operazione di attesa, un thread di lavoro del pool di thread esegue 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 metodo QueueUserWorkItem per accodare un metodo per l'esecuzione in un thread del pool di thread.When you call the QueueUserWorkItem method to queue a method for execution on a thread pool thread. A tale scopo, passare il metodo a un delegato WaitCallback.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)  
    

    dove state è un oggetto che contiene i dati che devono essere utilizzati 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 metodo QueueUserWorkItem(WaitCallback, Object).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. Ovvero le proprietà @no__t 0 sono true.That is, their IsBackground properties are true. Questo significa che un thread ThreadPool non manterrà un'applicazione in esecuzione dopo la chiusura 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 riutilizza un thread, non cancella i dati nell'archiviazione locale di thread o nei campi contrassegnati con l'attributo 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. Pertanto, quando un metodo esamina l'archiviazione locale di thread o i campi contrassegnati con l'attributo ThreadStaticAttribute, i valori trovati potrebbero essere rimasti da un utilizzo precedente del thread del pool di thread.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 che non sono correlati a un'operazione di attesa al 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 venga gestito da un thread nel pool di thread, chiamare il metodo QueueUserWorkItem.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 al 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 è stato accodato.There is no way to cancel a work item after it has been queued.

Timer: i timer della coda e le operazioni di attesa registrate utilizzano anche 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.

È presente un pool di thread per 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 usando il metodo SetMaxThreads.The number of threads in the thread pool can be changed by using the SetMaxThreads method. Ogni thread usa le dimensioni predefinite dello stack 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 il .NET Framework può modificare le dimensioni del pool di thread utilizzando la funzione CorSetMaxThreads, definita nel file 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 di I/O su richiesta fino a raggiungere 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 il 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

Per aumentare il numero minimo di thread, è possibile usare il metodo SetMinThreads.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.

Proprietà

CompletedWorkItemCount CompletedWorkItemCount CompletedWorkItemCount CompletedWorkItemCount

Ottiene il numero di elementi di lavoro che sono stati elaborati fino a questo momento.Gets the number of work items that have been processed so far.

PendingWorkItemCount PendingWorkItemCount PendingWorkItemCount PendingWorkItemCount

Ottiene il numero di elementi di lavoro attualmente in attesa di elaborazione.Gets the number of work items that are currently queued to be processed.

ThreadCount ThreadCount ThreadCount ThreadCount

Ottiene il numero di thread del pool di thread attualmente esistenti.Gets the number of thread pool threads that currently exist.

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)

Accoda l'oggetto elemento di lavoro specificato nel pool di thread.Queues the specified work item object to the thread pool.

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