Udostępnij za pośrednictwem


ThreadPool.QueueUserWorkItem Metoda

Definicja

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

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

callBack to null.

Ś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ż

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

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

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

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

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.

Zobacz też

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

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

Dotyczy