ThreadPool ThreadPool ThreadPool ThreadPool Class

Definição

Fornece um pool de threads que podem ser usados para executar tarefas, postar os itens de trabalho, processar E/S assíncrona, aguardar em nome de outros threads e processar temporizadores.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
Herança
ThreadPoolThreadPoolThreadPoolThreadPool

Exemplos

No exemplo a seguir, o thread principal do aplicativo enfileira um método chamado ThreadProc para executar em um pool de threads, dorme por um segundo e, em seguida, sai.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. O ThreadProc método simplesmente exibe uma mensagem.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 você comentar a chamada para o Thread.Sleep método, o thread principal é encerrado antes que o método é executado no thread do pool.If you comment out the call to the Thread.Sleep method, the main thread exits before method runs on the thread pool thread. O pool de threads usa threads em segundo plano, o que não mantém o aplicativo em execução se todos os threads de primeiro plano tiverem terminado.The thread pool uses background threads, which do not keep the application running if all foreground threads have terminated. (Isso é um exemplo simples de uma condição de corrida.)(This is a simple example of a race condition.)

Comentários

Muitos aplicativos criam threads que passam muito tempo no estado de repouso, aguardando um evento ocorra.Many applications create threads that spend a great deal of time in the sleeping state, waiting for an event to occur. Outros threads podem entrar em um estado suspenso apenas para ser despertado periodicamente para sondar uma alteração ou atualizar as informações de status.Other threads might enter a sleeping state only to be awakened periodically to poll for a change or update status information. O pool de threads permite que você use threads com mais eficiência, fornecendo seu aplicativo com um pool de threads de trabalho que são gerenciados pelo 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. Exemplos de operações que usam threads do pool incluem o seguinte:Examples of operations that use thread pool threads include the following:

  • Quando você cria um Task ou Task<TResult> objeto para executar uma tarefa de forma assíncrona, por padrão, a tarefa está agendada para execução em um 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.

  • Temporizadores assíncronos usam o pool de threads.Asynchronous timers use the thread pool. Retornos de chamada de execução do thread do pool de threads a System.Threading.Timer de classe e gerar eventos do 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 você usa identificadores de espera registrada, um thread do sistema monitora o status dos identificadores de espera.When you use registered wait handles, a system thread monitors the status of the wait handles. Quando uma operação de espera for concluída, um thread de trabalho do pool de threads executa a função de retorno de chamada correspondente.When a wait operation completes, a worker thread from the thread pool executes the corresponding callback function.

  • Quando você chama o QueueUserWorkItem método para enfileirar um método para execução em um pool de threads.When you call the QueueUserWorkItem method to queue a method for execution on a thread pool thread. Faça isso passando o método um WaitCallback delegar.You do this by passing the method a WaitCallback delegate. O delegado tem a assinaturaThe delegate has the signature

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

    onde state é um objeto que contém dados a serem usados pelo delegado.where state is an object that contains data to be used by the delegate. Os dados reais podem ser passados para o delegado, chamando o QueueUserWorkItem(WaitCallback, Object) método.The actual data can be passed to the delegate by calling the QueueUserWorkItem(WaitCallback, Object) method.

Observação

Os threads no pool de threads gerenciados são threads em segundo plano.The threads in the managed thread pool are background threads. Ou seja, seus IsBackground são propriedades true.That is, their IsBackground properties are true. Isso significa que um ThreadPool thread não manterá um aplicativo em execução depois que todos os threads de primeiro plano tenham saído.This means that a ThreadPool thread will not keep an application running after all foreground threads have exited.

Importante

Quando o pool de threads reutiliza um thread, ele não limpa os dados no armazenamento local de thread ou nos campos marcados com o ThreadStaticAttribute atributo.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. Portanto, quando um método examina o armazenamento local de thread ou campos que são marcados com o ThreadStaticAttribute atributo, os valores que ele encontra podem ser deixados de uso anterior do thread do 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.

Também é possível enfileirar itens de trabalho que não estão relacionados a uma operação de espera para o pool de threads.You can also queue work items that are not related to a wait operation to the thread pool. Para solicitar que um item de trabalho manipulada por um thread no pool de threads, chame o QueueUserWorkItem método.To request that a work item be handled by a thread in the thread pool, call the QueueUserWorkItem method. Esse método aceita como um parâmetro de uma referência para o método ou delegate que será chamado pelo thread selecionado do 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. Não há nenhuma maneira de cancelar um item de trabalho depois que ele foi enfileirado.There is no way to cancel a work item after it has been queued.

Temporizadores de fila do temporizador e operações de espera registrada também usam o pool de threads.Timer-queue timers and registered wait operations also use the thread pool. Suas funções de retorno de chamada são enfileiradas para o pool de threads.Their callback functions are queued to the thread pool.

Há um pool de threads por processo.There is one thread pool per process. A partir do .NET Framework 4.NET Framework 4, o tamanho padrão do pool de threads de um processo depende de vários fatores, como o tamanho do espaço de endereço virtual.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. Um processo pode chamar o método GetMaxThreads para determinar o número de threads.A process can call the GetMaxThreads method to determine the number of threads. O número de threads no pool de threads pode ser alterado usando o SetMaxThreads método.The number of threads in the thread pool can be changed by using the SetMaxThreads method. Cada thread usa o tamanho da pilha padrão e é executado com prioridade padrão.Each thread uses the default stack size and runs at the default priority.

Observação

Código não gerenciado que hospeda o .NET Framework pode alterar o tamanho do pool de threads usando a CorSetMaxThreads função, definida no arquivo 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.

O pool de threads fornece novos threads de trabalho ou threads de conclusão de e/s sob demanda até atingir o mínimo para cada categoria.The thread pool provides new worker threads or I/O completion threads on demand until it reaches the minimum for each category. Quando um mínimo for atingido, o pool de threads pode criar threads adicionais nessa categoria ou aguarde a conclusão de algumas tarefas.When a minimum is reached, the thread pool can create additional threads in that category or wait until some tasks complete. A partir do .NET Framework 4.NET Framework 4, o pool de threads cria e destrói threads de trabalho a fim de otimizar a taxa de transferência, que é definida como o número de tarefas concluídas por unidade de 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. Pouquíssimos threads podem não fazer um uso ideal dos recursos disponíveis, enquanto muitos threads podem aumentar a contenção de recursos.Too few threads might not make optimal use of available resources, whereas too many threads could increase resource contention.

Observação

Quando a demanda é baixa, o número real de threads do pool de threads pode ficar abaixo dos valores mínimos.When demand is low, the actual number of thread pool threads can fall below the minimum values.

Você pode usar o método GetMinThreads para obter esses valores mínimos.You can use the GetMinThreads method to obtain these minimum values.

Cuidado

Você pode usar o SetMinThreads método para aumentar o número mínimo de threads.You can use the SetMinThreads method to increase the minimum number of threads. No entanto, o aumento desnecessário desses valores pode causar problemas de desempenho.However, unnecessarily increasing these values can cause performance problems. Se muitas tarefas começarem ao mesmo tempo, todas elas podem parecer lentas.If too many tasks start at the same time, all of them might appear to be slow. Na maioria dos casos, o pool de threads terá um desempenho melhor com seu próprio algoritmo de alocação de threads.In most cases the thread pool will perform better with its own algorithm for allocating threads.

Propriedades

CompletedWorkItemCount CompletedWorkItemCount CompletedWorkItemCount CompletedWorkItemCount
PendingWorkItemCount PendingWorkItemCount PendingWorkItemCount PendingWorkItemCount
ThreadCount ThreadCount ThreadCount ThreadCount

Métodos

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

Associa um identificador de sistema operacional ao ThreadPool.Binds an operating system handle to the ThreadPool.

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

Associa um identificador de sistema operacional ao ThreadPool.Binds an operating system handle to the ThreadPool.

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

Recupera a diferença entre o número máximo de threads do pool de threads retornados pelo método GetMaxThreads(Int32, Int32) e o número de ativos no momento.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 o número de solicitações para o pool de threads que podem estar ativas simultaneamente.Retrieves the number of requests to the thread pool that can be active concurrently. Todas as solicitações acima desse número permanecem na fila até que os threads do pool de threads se tornem disponíveis.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 o número mínimo de threads que o pool de threads cria sob demanda à medida que novas solicitações são feitas, antes de mudar para um algoritmo a fim de gerenciar a criação e a destruição de 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)

Enfileira um método para execução.Queues a method for execution. O método é executado quando um thread de pool de threads se torna disponível.The method executes when a thread pool thread becomes available.

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

Enfileira um método para execução e especifica um objeto que contém dados a serem usados pelo método.Queues a method for execution, and specifies an object containing data to be used by the method. O método é executado quando um thread de pool de threads se torna disponível.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)

Enfileira um método especificado por um delegado de Action<T> para execução e fornece os dados a serem usados pelo método.Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. O método é executado quando um thread de pool de threads se torna disponível.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 um delegado para aguardar um WaitHandle, especificando um inteiro sem sinal de 32 bits para o tempo limite em milissegundos.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 um delegado para aguardar um WaitHandle, especificando um valor TimeSpan para o tempo limite.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 um delegado para esperar um WaitHandle, especificando um inteiro com sinal de 32 bits para o tempo limite em milissegundos.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 um delegado para esperar um WaitHandle, especificando um inteiro com sinal de 64 bits para o tempo limite em milissegundos.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)

Define o número de solicitações para o pool de threads que podem estar ativas simultaneamente.Sets the number of requests to the thread pool that can be active concurrently. Todas as solicitações acima desse número permanecem na fila até que os threads do pool de threads se tornem disponíveis.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)

Define o número mínimo de threads que o pool de threads cria sob demanda à medida que novas solicitações são feitas, antes de mudar para um algoritmo a fim de gerenciar a criação e a destruição de 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*)

Enfileira uma operação de E/S sobreposta para a execução.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)

Enfileira o delegado especificado no pool de threads, mas não propagar a pilha de chamadas para o thread de trabalho.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)

Enfileira um método especificado por um delegado de Action<T> para execução e especifica um objeto que contém os dados a serem usados pelo método.Queues a method specified by an Action<T> delegate for execution, and specifies an object containing data to be used by the method. O método é executado quando um thread de pool de threads se torna disponível.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 um delegado para aguardar um WaitHandle, especificando um valor TimeSpan para o tempo limite. Esse método não propaga a pilha de chamadas para o thread de trabalho.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 um representante para aguardar um WaitHandle, usando um inteiro com sinal de 32 bits para o tempo limite em milissegundos.Registers a delegate to wait for a WaitHandle, using a 32-bit signed integer for the time-out in milliseconds. Esse método não propaga a pilha de chamadas para o thread de trabalho.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 um delegado para esperar um WaitHandle, especificando um inteiro com sinal de 64 bits para o tempo limite em milissegundos.Registers a delegate to wait for a WaitHandle, specifying a 64-bit signed integer for the time-out in milliseconds. Esse método não propaga a pilha de chamadas para o thread de trabalho.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 um delegado para aguardar um WaitHandle, especificando um inteiro sem sinal de 32 bits para o tempo limite em milissegundos.Registers a delegate to wait for a WaitHandle, specifying a 32-bit unsigned integer for the time-out in milliseconds. Esse método não propaga a pilha de chamadas para o thread de trabalho.This method does not propagate the calling stack to the worker thread.

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.

Veja também