ThreadPool Classe

Definição

public ref class ThreadPool abstract sealed

public ref class ThreadPool sealed

public static class ThreadPool

public sealed class ThreadPool

type ThreadPool = class

Public Class ThreadPool

Public NotInheritable Class ThreadPool

Herança

Object

ThreadPool

Exemplos

No exemplo a seguir, o thread de aplicativo principal enfileira um método chamado ThreadProc para executar em um thread de pool de threads, dorme por um segundo e, em seguida, sai. O ThreadProc método simplesmente exibe uma mensagem.

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 será encerrado antes que o método seja executado no thread do pool de threads. O pool de threads usa threads em segundo plano, que não mantêm o aplicativo em execução se todos os threads em primeiro plano tiverem sido encerrados. (Este é um exemplo simples de uma condição de corrida.)

Comentários

Muitos aplicativos criam threads que passam muito tempo no estado de suspensão, aguardando que um evento ocorra. Outros threads podem entrar em um estado de suspensão apenas para serem acordados periodicamente para sondar uma alteração ou atualizar informações de status. O pool de threads permite que você use threads com mais eficiência fornecendo ao aplicativo um pool de threads de trabalho gerenciados pelo sistema. Exemplos de operações que usam threads de pool de threads incluem o seguinte:

• Quando você cria um Task objeto ou Task<TResult> para executar alguma tarefa de forma assíncrona, por padrão, a tarefa é agendada para ser executada em um thread do pool de threads.

• Os temporizadores assíncronos usam o pool de threads. Os threads do pool de threads executam retornos de chamada da System.Threading.Timer classe e geram eventos da System.Timers.Timer classe .

• Quando você usa identificadores de espera registrados, um thread do sistema monitora o status dos identificadores de espera. Quando uma operação de espera é concluída, um thread de trabalho do pool de threads executa a função de retorno de chamada correspondente.

• Quando você chama o QueueUserWorkItem método para enfileirar um método para execução em um thread de pool de threads. Você faz isso passando o método de um WaitCallback delegado. O delegado tem a assinatura

  void WaitCallback(Object state)
  

  Sub WaitCallback(state As Object)
  

  em state que é um objeto que contém dados a serem usados pelo delegado. Os dados reais podem ser passados para o delegado chamando o QueueUserWorkItem(WaitCallback, Object) método .

Você também pode enfileirar itens de trabalho que não estão relacionados a uma operação de espera para o pool de threads. Para solicitar que um item de trabalho seja tratado por um thread no pool de threads, chame o QueueUserWorkItem método . Esse método usa como parâmetro uma referência ao método ou delegado que será chamado pelo thread selecionado no pool de threads. Não há como cancelar um item de trabalho depois que ele tiver sido enfileirado.

Os temporizadores de fila de temporizadores e as operações de espera registradas também usam o pool de threads. Suas funções de retorno de chamada são enfileiradas no pool de threads.

Há um pool de threads por processo. A partir do .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. Um processo pode chamar o método GetMaxThreads para determinar o número de threads. O número de threads no pool de threads pode ser alterado usando o SetMaxThreads método . Cada thread usa o tamanho da pilha padrão e é executado na prioridade padrão.

O pool de threads fornece novos threads de trabalho ou threads de conclusão de E/S sob demanda até atingir o máximo de cada categoria. Quando um máximo é atingido, o pool de threads pode criar threads adicionais nessa categoria ou aguardar até que algumas tarefas sejam concluídas. A partir do .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. Pouquíssimos threads podem não fazer um uso ideal dos recursos disponíveis, enquanto muitos threads podem aumentar a contenção de recursos.

Você pode usar o método GetMinThreads para obter esses valores mínimos.

Propriedades

Métodos

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.

Confira também

• Threads e threading
• O pooling de thread gerenciado