ThreadPool.QueueUserWorkItem Método

Referência

Definição

Namespace:: System.Threading

Assembly:: System.Threading.ThreadPool.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Enfileira um método para execução. O método é executado quando um thread de pool de threads se torna disponível.

Sobrecargas

QueueUserWorkItem(WaitCallback)	Enfileira um método para execução. O método é executado quando um thread de pool de threads se torna disponível.
QueueUserWorkItem(WaitCallback, Object)	Enfileira um método para execução e especifica um objeto que contém dados a serem usados pelo método. O método é executado quando um thread de pool de threads se torna disponível.
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. O método é executado quando um thread de pool de threads se torna disponível.

QueueUserWorkItem(WaitCallback)

Origem:: ThreadPoolWorkQueue.cs

Origem:: ThreadPoolWorkQueue.cs

Origem:: ThreadPoolWorkQueue.cs

Enfileira um método para execução. O método é executado quando um thread de pool de threads se torna disponível.

public:
 static bool QueueUserWorkItem(System::Threading::WaitCallback ^ callBack);

public static bool QueueUserWorkItem (System.Threading.WaitCallback callBack);

static member QueueUserWorkItem : System.Threading.WaitCallback -> bool

Public Shared Function QueueUserWorkItem (callBack As WaitCallback) As Boolean

Parâmetros

callBack: WaitCallback

Um WaitCallback que representa o método a ser executado.

Retornos

Boolean

true se o método for colocado na fila com êxito; NotSupportedException será gerado se o item de trabalho não puder ser colocado na fila.

Exceções

ArgumentNullException

callBack é null.

NotSupportedException

O CLR (Common Language Runtime) está hospedado e o host não dá suporte a essa ação.

Exemplos

O exemplo a seguir usa a sobrecarga do QueueUserWorkItem(WaitCallback) método para enfileirar uma tarefa, que é representada pelo ThreadProc método , para executar quando um thread fica disponível. Nenhuma informação de tarefa é fornecida com essa sobrecarga. Portanto, as informações disponíveis para o ThreadProc método são limitadas ao objeto ao qual o método pertence.

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.

Comentários

Você pode colocar os dados exigidos pelo método enfileirado nos campos de instância da classe na qual o método está definido ou pode usar a QueueUserWorkItem(WaitCallback, Object) sobrecarga que aceita um objeto que contém os dados necessários.

Observação

Os usuários do Visual Basic podem omitir o WaitCallback construtor e simplesmente usar o AddressOf operador ao passar o método de retorno de chamada para QueueUserWorkItem. O Visual Basic chama automaticamente o construtor delegado correto.

O Thread.CurrentPrincipal valor da propriedade é propagado para threads de trabalho enfileirados usando o QueueUserWorkItem método .

Confira também

O pool de threads gerenciados

Aplica-se a

QueueUserWorkItem(WaitCallback, Object)

Origem:: ThreadPoolWorkQueue.cs

Origem:: ThreadPoolWorkQueue.cs

Origem:: ThreadPoolWorkQueue.cs

Enfileira um método para execução e especifica um objeto que contém dados a serem usados pelo método. O método é executado quando um thread de pool de threads se torna disponível.

public:
 static bool QueueUserWorkItem(System::Threading::WaitCallback ^ callBack, System::Object ^ state);

public static bool QueueUserWorkItem (System.Threading.WaitCallback callBack, object? state);

public static bool QueueUserWorkItem (System.Threading.WaitCallback callBack, object state);

static member QueueUserWorkItem : System.Threading.WaitCallback * obj -> bool

Public Shared Function QueueUserWorkItem (callBack As WaitCallback, state As Object) As Boolean

Parâmetros

callBack: WaitCallback

Um WaitCallback que representa o método a ser executado.

state: Object

Um objeto que contém dados a serem usados pelo método.

Retornos

Boolean

true se o método for colocado na fila com êxito; NotSupportedException será gerado se o item de trabalho não puder ser colocado na fila.

Exceções

NotSupportedException

O CLR (Common Language Runtime) está hospedado e o host não dá suporte a essa ação.

ArgumentNullException

callBack é null.

Exemplos

O exemplo a seguir usa o pool de threads do .NET para calcular o Fibonacci resultado de cinco números entre 20 e 40. Cada resultado Fibonacci é representado pela classe Fibonacci, que fornece um método chamado ThreadPoolCallback que executa o cálculo. Um objeto que representa cada valor Fibonacci é criado e o método ThreadPoolCallback é passado para QueueUserWorkItem, que atribui um thread disponível no pool para executar o método.

Como cada Fibonacci objeto recebe um valor semi-aleatório para computação e, como cada thread estará competindo pelo tempo do processador, você não pode saber com antecedência quanto tempo levará para que todos os cinco resultados sejam calculados. É por isso que cada objeto Fibonacci é passado a uma instância da classe ManualResetEvent durante a construção. Cada objeto sinaliza o objeto de evento fornecido quando seu cálculo é concluído, o que permite que o thread primário bloqueie a execução até WaitAll que todos os cinco Fibonacci objetos tenham calculado um resultado. O método Main exibe então cada resultado de Fibonacci.

using namespace System;
using namespace System::Threading;

public ref class Fibonacci
{
private:
    ManualResetEvent^ _doneEvent;

    int Calculate(int n)
    {
        if (n <= 1)
        {
            return n;
        }
        return Calculate(n - 1) + Calculate(n - 2);
    }

public:
    
    int ID;
    int N;
    int FibOfN;

    Fibonacci(int id, int n, ManualResetEvent^ doneEvent)
    {
        ID = id;
        N = n;
        _doneEvent = doneEvent;
    }

    void Calculate()
    {
        FibOfN = Calculate(N);
    }

    void SetDone()
    {
        _doneEvent->Set();
    }
};

public ref struct Example
{
public:

    static void ThreadProc(Object^ stateInfo)
    {
        Fibonacci^ f = dynamic_cast<Fibonacci^>(stateInfo);
        Console::WriteLine("Thread {0} started...", f->ID);
        f->Calculate();
        Console::WriteLine("Thread {0} result calculated...", f->ID);
        f->SetDone();
    }
};


void main()
{
    const int FibonacciCalculations = 5;

    array<ManualResetEvent^>^ doneEvents = gcnew array<ManualResetEvent^>(FibonacciCalculations);
    array<Fibonacci^>^ fibArray = gcnew array<Fibonacci^>(FibonacciCalculations);
    Random^ rand = gcnew Random();

    Console::WriteLine("Launching {0} tasks...", FibonacciCalculations);

    for (int i = 0; i < FibonacciCalculations; i++)
    {
        doneEvents[i] = gcnew ManualResetEvent(false);
        Fibonacci^ f = gcnew Fibonacci(i, rand->Next(20, 40), doneEvents[i]);
        fibArray[i] = f;
        ThreadPool::QueueUserWorkItem(gcnew WaitCallback(Example::ThreadProc), f);
    }

    WaitHandle::WaitAll(doneEvents);
    Console::WriteLine("All calculations are complete.");

    for (int i = 0; i < FibonacciCalculations; i++)
    {
        Fibonacci^ f = fibArray[i];
        Console::WriteLine("Fibonacci({0}) = {1}", f->N, f->FibOfN);
    }
}
// Output is similar to:
// Launching 5 tasks...
// Thread 3 started...
// Thread 2 started...
// Thread 1 started...
// Thread 0 started...
// Thread 4 started...
// Thread 4 result calculated...
// Thread 1 result calculated...
// Thread 2 result calculated...
// Thread 0 result calculated...
// Thread 3 result calculated...
// All calculations are complete.
// Fibonacci(30) = 832040
// Fibonacci(24) = 46368
// Fibonacci(26) = 121393
// Fibonacci(36) = 14930352
// Fibonacci(20) = 6765

using System;
using System.Threading;

public class Fibonacci
{
    private ManualResetEvent _doneEvent;

    public Fibonacci(int n, ManualResetEvent doneEvent)
    {
        N = n;
        _doneEvent = doneEvent;
    }

    public int N { get; }

    public int FibOfN { get; private set; }

    public void ThreadPoolCallback(Object threadContext)
    {
        int threadIndex = (int)threadContext;
        Console.WriteLine($"Thread {threadIndex} started...");
        FibOfN = Calculate(N);
        Console.WriteLine($"Thread {threadIndex} result calculated...");
        _doneEvent.Set();
    }

    public int Calculate(int n)
    {
        if (n <= 1)
        {
            return n;
        }
        return Calculate(n - 1) + Calculate(n - 2);
    }
}

public class ThreadPoolExample
{
    static void Main()
    {
        const int FibonacciCalculations = 5;

        var doneEvents = new ManualResetEvent[FibonacciCalculations];
        var fibArray = new Fibonacci[FibonacciCalculations];
        var rand = new Random();

        Console.WriteLine($"Launching {FibonacciCalculations} tasks...");
        for (int i = 0; i < FibonacciCalculations; i++)
        {
            doneEvents[i] = new ManualResetEvent(false);
            var f = new Fibonacci(rand.Next(20, 40), doneEvents[i]);
            fibArray[i] = f;
            ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);
        }

        WaitHandle.WaitAll(doneEvents);
        Console.WriteLine("All calculations are complete.");

        for (int i = 0; i < FibonacciCalculations; i++)
        {
            Fibonacci f = fibArray[i];
            Console.WriteLine($"Fibonacci({f.N}) = {f.FibOfN}");
        }
    }
}
// The output is similar to:
// Launching 5 tasks...
// Thread 3 started...
// Thread 4 started...
// Thread 2 started...
// Thread 1 started...
// Thread 0 started...
// Thread 2 result calculated...
// Thread 3 result calculated...
// Thread 4 result calculated...
// Thread 1 result calculated...
// Thread 0 result calculated...
// All calculations are complete.
// Fibonacci(35) = 9227465
// Fibonacci(27) = 196418
// Fibonacci(25) = 75025
// Fibonacci(25) = 75025
// Fibonacci(27) = 196418

Imports System.Threading

Public Class Fibonacci
    Private _doneEvent As ManualResetEvent

    Public Sub New(n As Integer, doneEvent As ManualResetEvent)
        Me.N = n
        _doneEvent = doneEvent
    End Sub

    Public ReadOnly Property N As Integer
    Public Property FibOfN As Integer

    Public Sub ThreadPoolCallback(threadContext As Object)
        Dim threadIndex As Integer = CType(threadContext, Integer)
        Console.WriteLine($"Thread {threadIndex} started...")
        FibOfN = Calculate(N)
        Console.WriteLine($"Thread {threadIndex} result calculated...")
        _doneEvent.Set()
    End Sub

    Public Function Calculate(n As Integer) As Integer
        If (n <= 1) Then
            Return n
        End If
        Return Calculate(n - 1) + Calculate(n - 2)
    End Function
End Class

Public Class ThreadPoolExample

    <MTAThread>
    Public Shared Sub Main()

        Const FibonacciCalculations As Integer = 5

        Dim doneEvents(FibonacciCalculations - 1) As ManualResetEvent
        Dim fibArray(FibonacciCalculations - 1) As Fibonacci
        Dim rand As Random = New Random()

        Console.WriteLine($"Launching {FibonacciCalculations} tasks...")

        For i As Integer = 0 To FibonacciCalculations - 1
            doneEvents(i) = New ManualResetEvent(False)
            Dim f As Fibonacci = New Fibonacci(rand.Next(20, 40), doneEvents(i))
            fibArray(i) = f
            ThreadPool.QueueUserWorkItem(AddressOf f.ThreadPoolCallback, i)
        Next

        WaitHandle.WaitAll(doneEvents)
        Console.WriteLine("All calculations are complete.")

        For i As Integer = 0 To FibonacciCalculations - 1
            Dim f As Fibonacci = fibArray(i)
            Console.WriteLine($"Fibonacci({f.N}) = {f.FibOfN}")
        Next
    End Sub
End Class
' Output is similar to
' Launching 5 tasks...
' Thread 1 started...
' Thread 2 started...
' Thread 3 started...
' Thread 4 started...
' Thread 0 started...
' Thread 4 result calculated...
' Thread 2 result calculated...
' Thread 3 result calculated...
' Thread 0 result calculated...
' Thread 1 result calculated...
' All calculations are complete.
' Fibonacci(37) = 24157817
' Fibonacci(38) = 39088169
' Fibonacci(29) = 514229
' Fibonacci(32) = 2178309
' Fibonacci(23) = 28657

Comentários

Se o método de retorno de chamada exigir dados complexos, você poderá definir uma classe para conter os dados.

Observação

Confira também

O pool de threads gerenciados

Aplica-se a

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

Origem:: ThreadPoolWorkQueue.cs

Origem:: ThreadPoolWorkQueue.cs

Origem:: ThreadPoolWorkQueue.cs

Enfileira um método especificado por um delegado de Action<T> para execução e fornece os dados a serem usados pelo método. O método é executado quando um thread de pool de threads se torna disponível.

public:
generic <typename TState>
 static bool QueueUserWorkItem(Action<TState> ^ callBack, TState state, bool preferLocal);

public static bool QueueUserWorkItem<TState> (Action<TState> callBack, TState state, bool preferLocal);

static member QueueUserWorkItem : Action<'State> * 'State * bool -> bool

Public Shared Function QueueUserWorkItem(Of TState) (callBack As Action(Of TState), state As TState, preferLocal As Boolean) As Boolean

Parâmetros de tipo

TState

O tipo dos elementos de state.

Parâmetros

callBack: Action<TState>

Um Action<T> que representa o método a ser executado.

state: TState

Um objeto que contém dados a serem usados pelo método.

preferLocal: Boolean

true para indicar a preferência por colocar o item de trabalho em uma fila próximo ao thread atual; false para indicar a preferência por colocar o item de trabalho na fila compartilhada do pool de threads.

Retornos

Boolean

true se o método for colocado na fila com êxito; NotSupportedException será gerado se o item de trabalho não puder ser colocado na fila.

Aplica-se a

Compartilhar via

ThreadPool.QueueUserWorkItem Método

Definição

Sobrecargas

QueueUserWorkItem(WaitCallback)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

QueueUserWorkItem(WaitCallback, Object)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

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

Parâmetros de tipo

Parâmetros

Retornos

Aplica-se a

Recursos adicionais