ThreadPool.QueueUserWorkItem Methode

Definition

Fügt der Warteschlange eine auszuführende Methode hinzu. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.

Überlädt

QueueUserWorkItem(WaitCallback)

Fügt der Warteschlange eine auszuführende Methode hinzu. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.

QueueUserWorkItem(WaitCallback, Object)

Fügt der Warteschlange eine auszuführende Methode hinzu und gibt ein Objekt an, das die von der Methode zu verwendenden Daten enthält. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.

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

Fügt der Warteschlange eine Methode hinzu, die von einem Action<T>-Delegat zur Ausführung angegeben wird, und stellt die von der Methode zu verwendenden Daten bereit. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.

QueueUserWorkItem(WaitCallback)

Fügt der Warteschlange eine auszuführende Methode hinzu. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.

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

Parameter

callBack
WaitCallback

Ein WaitCallback, der die auszuführende Methode darstellt.

Gibt zurück

true, wenn die Methode erfolgreich in die Warteschlange eingereiht wurde. NotSupportedException wird ausgelöst, wenn das Arbeitselement nicht in die Warteschlange eingereiht werden konnte.

Ausnahmen

callBack ist null.

Die Common Language Runtime (CLR) wird gehostet, und der Host unterstützt diese Aktion nicht.

Beispiele

Im folgenden Beispiel wird die QueueUserWorkItem(WaitCallback) Methodenüberladung verwendet, um eine Aufgabe, die durch die -Methode dargestellt wird, in die ThreadProc Warteschlange zu stellen, die ausgeführt wird, wenn ein Thread verfügbar wird. Mit dieser Überladung werden keine Vorgangsinformationen bereitgestellt. Daher sind die Informationen, die der ThreadProc -Methode zur Verfügung stehen, auf das Objekt beschränkt, zu dem die Methode gehört.

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.

Hinweise

Sie können die für die Methode in der Warteschlange erforderlichen Daten in den instance Feldern der Klasse platzieren, in der die Methode definiert ist, oder Sie können die Überladung verwenden, die QueueUserWorkItem(WaitCallback, Object) ein Objekt akzeptiert, das die erforderlichen Daten enthält.

Hinweis

Visual Basic-Benutzer können den WaitCallback Konstruktor weglassen und einfach den AddressOf Operator verwenden, wenn sie die Rückrufmethode an QueueUserWorkItemübergeben. Visual Basic ruft automatisch den richtigen Delegatkonstruktor auf.

Der Thread.CurrentPrincipal -Eigenschaftswert wird an Workerthreads weitergegeben, die mithilfe der -Methode in die QueueUserWorkItem Warteschlange eingereiht werden.

Weitere Informationen

Gilt für:

QueueUserWorkItem(WaitCallback, Object)

Fügt der Warteschlange eine auszuführende Methode hinzu und gibt ein Objekt an, das die von der Methode zu verwendenden Daten enthält. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.

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

Parameter

callBack
WaitCallback

Ein WaitCallback, der die auszuführende Methode darstellt.

state
Object

Ein Objekt, das die von der Methode zu verwendenden Daten enthält.

Gibt zurück

true, wenn die Methode erfolgreich in die Warteschlange eingereiht wurde. NotSupportedException wird ausgelöst, wenn das Arbeitselement nicht in die Warteschlange eingereiht werden konnte.

Ausnahmen

Die Common Language Runtime (CLR) wird gehostet, und der Host unterstützt diese Aktion nicht.

callBack ist null.

Beispiele

Im folgenden Beispiel wird der .NET-Threadpool verwendet, um das Fibonacci Ergebnis für fünf Zahlen zwischen 20 und 40 zu berechnen. Jedes Fibonacci-Ergebnis wird von der Fibonacci-Klasse repräsentiert, die eine Methode mit dem Namen ThreadPoolCallback bietet, die die Berechnung durchführt. Ein Objekt, das jeden Fibonacci-Wert repräsentiert, wird erstellt, und die ThreadPoolCallback-Methode wird an QueueUserWorkItem übergeben, das dem Pool einen verfügbaren Thread zuweist, um die Methode auszuführen.

Da jedes Fibonacci Objekt einen semi-zufälligen Wert für die Berechnung erhält und jeder Thread um die Prozessorzeit konkurrieren wird, können Sie nicht im Voraus wissen, wie lange es dauert, bis alle fünf Ergebnisse berechnet werden. Deshalb wird jedem Fibonacci-Objekt eine Instanz der ManualResetEvent-Klasse während der Konstruktion übergeben. Jedes Objekt signalisiert das bereitgestellte Ereignisobjekt, wenn seine Berechnung abgeschlossen ist, wodurch der primäre Thread die Ausführung mit WaitAll blockieren kann, bis alle fünf Fibonacci Objekte ein Ergebnis berechnet haben. Die Main-Methode zeigt dann jedes Fibonacci-Ergebnis an.

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

Hinweise

Wenn die Rückrufmethode komplexe Daten erfordert, können Sie eine Klasse definieren, die die Daten enthält.

Hinweis

Visual Basic-Benutzer können den WaitCallback Konstruktor weglassen und einfach den AddressOf Operator verwenden, wenn sie die Rückrufmethode an QueueUserWorkItemübergeben. Visual Basic ruft automatisch den richtigen Delegatkonstruktor auf.

Weitere Informationen

Gilt für:

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

Fügt der Warteschlange eine Methode hinzu, die von einem Action<T>-Delegat zur Ausführung angegeben wird, und stellt die von der Methode zu verwendenden Daten bereit. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.

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

Typparameter

TState

Der Typ der Elemente von state.

Parameter

callBack
Action<TState>

Eine Action<T>, die die auszuführende Methode darstellt.

state
TState

Ein Objekt, das die von der Methode zu verwendenden Daten enthält.

preferLocal
Boolean

Mit true fügen Sie das Arbeitselement in eine Warteschlange in der Nähe des aktuellen Threads ein; false für das Einfügen des Arbeitselements in die vom Threadpool freigegebene Warteschlange.

Gibt zurück

true, wenn die Methode erfolgreich in die Warteschlange eingereiht wurde. NotSupportedException wird ausgelöst, wenn das Arbeitselement nicht in die Warteschlange eingereiht werden konnte.

Gilt für: