ThreadPool.QueueUserWorkItem Método

Definición

Pone en cola un método para su ejecución.Queues a method for execution. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

Sobrecargas

QueueUserWorkItem(WaitCallback)

Pone en cola un método para su ejecución.Queues a method for execution. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback, Object)

Pone un método en cola para su ejecución y especifica un objeto que contiene los datos que debe usar el método.Queues a method for execution, and specifies an object containing data to be used by the method. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

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

Pone un método en cola para su ejecución especificado por un delegado de Action<T> y proporciona los datos que debe usar el método.Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback)

Pone en cola un método para su ejecución.Queues a method for execution. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

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

WaitCallback que representa el método que se va a ejecutar.A WaitCallback that represents the method to be executed.

Devoluciones

true si el método se pone en la cola correctamente; se produce la excepción NotSupportedException si no se puede poner en la cola el elemento de trabajo.true if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

Excepciones

callBack es null.callBack is null.

Common Language Runtime (CLR) está en un host y el host no admite esta acción.The common language runtime (CLR) is hosted, and the host does not support this action.

Ejemplos

En el ejemplo siguiente se usa la sobrecarga del método QueueUserWorkItem(WaitCallback) para poner en cola una tarea, que está representada por el método ThreadProc, para ejecutar cuando un subproceso está disponible.The following example uses the QueueUserWorkItem(WaitCallback) method overload to queue a task, which is represented by the ThreadProc method, to execute when a thread becomes available. No se proporciona ninguna información de tarea con esta sobrecarga.No task information is supplied with this overload. Por lo tanto, la información que está disponible para el método ThreadProc se limita al objeto al que pertenece el método.Therefore, the information that is available to the ThreadProc method is limited to the object the method belongs to.

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.

Comentarios

Puede colocar los datos requeridos por el método en cola en los campos de instancia de la clase en la que se define el método, o puede usar la sobrecarga QueueUserWorkItem(WaitCallback, Object) que acepta un objeto que contiene los datos necesarios.You can place data required by the queued method in the instance fields of the class in which the method is defined, or you can use the QueueUserWorkItem(WaitCallback, Object) overload that accepts an object containing the necessary data.

Nota

Visual Basic usuarios pueden omitir el constructor WaitCallback y, simplemente, usar el operador AddressOf al pasar el método de devolución de llamada a QueueUserWorkItem.Visual Basic users can omit the WaitCallback constructor, and simply use the AddressOf operator when passing the callback method to QueueUserWorkItem. Visual Basic llama automáticamente al constructor de delegado correcto.Visual Basic automatically calls the correct delegate constructor.

Información de versiónVersion Information

En la .NET Framework versión 2,0, el valor de la propiedad Thread.CurrentPrincipal se propaga a los subprocesos de trabajo en cola mediante el método QueueUserWorkItem.In the .NET Framework version 2.0, the Thread.CurrentPrincipal property value is propagated to worker threads queued using the QueueUserWorkItem method. En versiones anteriores, la información de la entidad de seguridad no se propaga.In earlier versions, the principal information is not propagated.

Consulte también:

QueueUserWorkItem(WaitCallback, Object)

Pone un método en cola para su ejecución y especifica un objeto que contiene los datos que debe usar el método.Queues a method for execution, and specifies an object containing data to be used by the method. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

public:
 static bool QueueUserWorkItem(System::Threading::WaitCallback ^ callBack, System::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

WaitCallback que representa el método que se va a ejecutar.A WaitCallback representing the method to execute.

state
Object

Objeto que contiene los datos que va a usar el método.An object containing data to be used by the method.

Devoluciones

true si el método se pone en la cola correctamente; se produce la excepción NotSupportedException si no se puede poner en la cola el elemento de trabajo.true if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

Excepciones

Common Language Runtime (CLR) está en un host y el host no admite esta acción.The common language runtime (CLR) is hosted, and the host does not support this action.

callBack es null.callBack is null.

Ejemplos

En el ejemplo siguiente se usa el grupo de subprocesos de .NET para calcular el resultado de Fibonacci para cinco números entre 20 y 40.The following example uses the .NET thread pool to calculate the Fibonacci result for five numbers between 20 and 40. Cada resultado de Fibonacci se representa mediante la clase Fibonacci, que proporciona un método denominado ThreadPoolCallback que realiza el cálculo.Each Fibonacci result is represented by the Fibonacci class, which provides a method named ThreadPoolCallback that performs the calculation. Se crea un objeto que representa cada valor de Fibonacci y el método ThreadPoolCallback se pasa a QueueUserWorkItem, que asigna un subproceso disponible en el grupo para ejecutar el método.An object that represents each Fibonacci value is created, and the ThreadPoolCallback method is passed to QueueUserWorkItem, which assigns an available thread in the pool to execute the method.

Dado que cada objeto Fibonacci recibe un valor semialeatorio para calcular, y dado que cada subproceso va a competir por el tiempo de procesador, no puede saber de antemano cuánto tardará en calcularse los cinco resultados.Because each Fibonacci object is given a semi-random value to compute, and because each thread will be competing for processor time, you cannot know in advance how long it will take for all five results to be calculated. Por eso se pasa a cada objeto Fibonacci una instancia de la clase ManualResetEvent durante la construcción.That is why each Fibonacci object is passed an instance of the ManualResetEvent class during construction. Cada objeto señala el objeto de evento proporcionado cuando se completa el cálculo, lo que permite que el subproceso principal bloquee la ejecución con WaitAll hasta que los cinco objetos Fibonacci hayan calculado un resultado.Each object signals the provided event object when its calculation is complete, which allows the primary thread to block execution with WaitAll until all five Fibonacci objects have calculated a result. El método Main muestra entonces cada resultado de Fibonacci.The Main method then displays each Fibonacci result.

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

Comentarios

Si el método de devolución de llamada requiere datos complejos, puede definir una clase que contenga los datos.If the callback method requires complex data, you can define a class to contain the data.

Nota

Visual Basic usuarios pueden omitir el constructor WaitCallback y, simplemente, usar el operador AddressOf al pasar el método de devolución de llamada a QueueUserWorkItem.Visual Basic users can omit the WaitCallback constructor, and simply use the AddressOf operator when passing the callback method to QueueUserWorkItem. Visual Basic llama automáticamente al constructor de delegado correcto.Visual Basic automatically calls the correct delegate constructor.

Información de versiónVersion Information

En la .NET Framework versión 2,0, el valor de la propiedad Thread.CurrentPrincipal se propaga a los subprocesos de trabajo en cola mediante el método QueueUserWorkItem.In the .NET Framework version 2.0, the Thread.CurrentPrincipal property value is propagated to worker threads queued using the QueueUserWorkItem method. En versiones anteriores, la información de la entidad de seguridad no se propaga.In earlier versions, the principal information is not propagated.

Consulte también:

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

Pone un método en cola para su ejecución especificado por un delegado de Action<T> y proporciona los datos que debe usar el método.Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

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

Tipo de elementos de state.The type of elements of state.

Parámetros

callBack
Action<TState>

Action<T> que representa el método que se va a ejecutar.An Action<T> representing the method to execute.

state
TState

Objeto que contiene los datos que va a usar el método.An object containing data to be used by the method.

preferLocal
Boolean

true si se prefiere poner en cola el elemento de trabajo en una cola junto al subproceso actual; false si se prefiere poner en cola el elemento de trabajo en la cola compartida del grupo de subprocesos.true to prefer queueing the work item in a queue close to the current thread; false to prefer queueing the work item to the thread pool's shared queue.

Devoluciones

true si el método se pone en la cola correctamente; se produce la excepción NotSupportedException si no se puede poner en la cola el elemento de trabajo.true if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued. ..

Se aplica a