ThreadPool.QueueUserWorkItem Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Threading

Zestaw:: System.Threading.ThreadPool.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Kolejkuje metodę wykonywania. Metoda jest wykonywana, gdy wątek puli wątków stanie się dostępny.

Przeciążenia

QueueUserWorkItem(WaitCallback)	Kolejkuje metodę wykonywania. Metoda jest wykonywana, gdy wątek puli wątków stanie się dostępny.
QueueUserWorkItem(WaitCallback, Object)	Kolejkuje metodę wykonywania i określa obiekt zawierający dane, które mają być używane przez metodę . Metoda jest wykonywana, gdy wątek puli wątków stanie się dostępny.
QueueUserWorkItem<TState>(Action<TState>, TState, Boolean)	Kolejkuje metodę określoną przez Action<T> delegata do wykonania i dostarcza dane, które mają być używane przez metodę . Metoda jest wykonywana, gdy wątek puli wątków stanie się dostępny.

QueueUserWorkItem(WaitCallback)

Źródło:: ThreadPoolWorkQueue.cs

Źródło:: ThreadPoolWorkQueue.cs

Źródło:: ThreadPoolWorkQueue.cs

Kolejkuje metodę wykonywania. Metoda jest wykonywana, gdy wątek puli wątków stanie się dostępny.

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

Parametry

callBack: WaitCallback

Obiekt WaitCallback reprezentujący metodę do wykonania.

Zwraca

Boolean

true jeśli metoda została pomyślnie w kolejce; NotSupportedException jest zgłaszany, jeśli nie można w kolejce elementu roboczego.

Wyjątki

ArgumentNullException

callBack to null.

NotSupportedException

Środowisko uruchomieniowe języka wspólnego (CLR) jest hostowane, a host nie obsługuje tej akcji.

Przykłady

W poniższym przykładzie użyto QueueUserWorkItem(WaitCallback) przeciążenia metody do kolejki zadania, które jest reprezentowane przez ThreadProc metodę, do wykonania, gdy wątek stanie się dostępny. Żadne informacje o zadaniu nie są dostarczane z tym przeciążeniem. W związku z tym informacje dostępne dla ThreadProc metody są ograniczone do obiektu, do którego należy metoda.

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.

Uwagi

Dane wymagane przez metodę w kolejce można umieścić w polach wystąpienia klasy, w której zdefiniowano metodę, lub użyć QueueUserWorkItem(WaitCallback, Object) przeciążenia, które akceptuje obiekt zawierający niezbędne dane.

Uwaga

Użytkownicy języka Visual Basic mogą pominąć WaitCallback konstruktor i po prostu użyć AddressOf operatora podczas przekazywania metody wywołania zwrotnego do QueueUserWorkItemmetody . Program Visual Basic automatycznie wywołuje prawidłowy konstruktor delegata.

Wartość Thread.CurrentPrincipal właściwości jest propagowana do wątków roboczych w kolejce przy użyciu QueueUserWorkItem metody .

Zobacz też

Zarządzana pula wątków

Dotyczy

QueueUserWorkItem(WaitCallback, Object)

Źródło:: ThreadPoolWorkQueue.cs

Źródło:: ThreadPoolWorkQueue.cs

Źródło:: ThreadPoolWorkQueue.cs

Kolejkuje metodę wykonywania i określa obiekt zawierający dane, które mają być używane przez metodę . Metoda jest wykonywana, gdy wątek puli wątków stanie się dostępny.

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

Parametry

callBack: WaitCallback

Reprezentujący WaitCallback metodę do wykonania.

state: Object

Obiekt zawierający dane, które mają być używane przez metodę .

Zwraca

Boolean

true jeśli metoda została pomyślnie w kolejce; NotSupportedException jest zgłaszany, jeśli nie można w kolejce elementu roboczego.

Wyjątki

NotSupportedException

Środowisko uruchomieniowe języka wspólnego (CLR) jest hostowane, a host nie obsługuje tej akcji.

ArgumentNullException

callBack to null.

Przykłady

W poniższym przykładzie użyto puli wątków platformy .NET do obliczenia Fibonacci wyniku dla pięciu liczb z zakresu od 20 do 40. Każdy Fibonacci wynik jest reprezentowany przez klasę Fibonacci , która udostępnia metodę o nazwie ThreadPoolCallback , która wykonuje obliczenia. Tworzony jest obiekt reprezentujący każdą Fibonacci wartość, a ThreadPoolCallback metoda jest przekazywana do QueueUserWorkItemmetody , która przypisuje dostępny wątek w puli w celu wykonania metody .

Ponieważ każdy Fibonacci obiekt otrzymuje częściowo losową wartość do obliczenia i dlatego, że każdy wątek będzie konkurować o czas procesora, nie można wiedzieć z wyprzedzeniem, jak długo potrwa to dla wszystkich pięciu wyników do obliczenia. Dlatego każdy Fibonacci obiekt jest przekazywany jako wystąpienie ManualResetEvent klasy podczas budowy. Każdy obiekt sygnalizuje podany obiekt zdarzenia po zakończeniu jego obliczenia, co umożliwia wątkowi podstawowemu blokowanie wykonywania z wartością WaitAll do momentu obliczenia wyniku przez wszystkie pięć Fibonacci obiektów. Następnie Main metoda wyświetla każdy Fibonacci wynik.

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

Uwagi

Jeśli metoda wywołania zwrotnego wymaga złożonych danych, można zdefiniować klasę do przechowywania danych.

Uwaga

Zobacz też

Zarządzana pula wątków

Dotyczy

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

Źródło:: ThreadPoolWorkQueue.cs

Źródło:: ThreadPoolWorkQueue.cs

Źródło:: ThreadPoolWorkQueue.cs

Kolejkuje metodę określoną przez Action<T> delegata do wykonania i dostarcza dane, które mają być używane przez metodę . Metoda jest wykonywana, gdy wątek puli wątków stanie się dostępny.

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

Parametry typu

TState

Typ elementów elementu state.

Parametry

callBack: Action<TState>

Reprezentująca Action<T> metodę do wykonania.

state: TState

Obiekt zawierający dane, które mają być używane przez metodę .

preferLocal: Boolean

true aby preferować kolejkowanie elementu roboczego w kolejce w pobliżu bieżącego wątku; false aby preferować kolejkowanie elementu roboczego do udostępnionej kolejki puli wątków.

Zwraca

Boolean

true jeśli metoda została pomyślnie w kolejce; NotSupportedException jest zgłaszany, jeśli nie można w kolejce elementu roboczego.

Dotyczy

Udostępnij za pośrednictwem

ThreadPool.QueueUserWorkItem Metoda

Definicja

Przeciążenia

QueueUserWorkItem(WaitCallback)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

QueueUserWorkItem(WaitCallback, Object)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

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

Parametry typu

Parametry

Zwraca

Dotyczy

Dodatkowe zasoby