ThreadPool.QueueUserWorkItem Metoda

Reference

Definice

Obor názvů:: System.Threading

Sestavení:: System.Threading.ThreadPool.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Zatáčí metodu pro spuštění do fronty. Metoda se spustí, když je k dispozici vlákno fondu vláken.

Přetížení

QueueUserWorkItem(WaitCallback)	Zatáčí metodu pro spuštění do fronty. Metoda se spustí, když je k dispozici vlákno fondu vláken.
QueueUserWorkItem(WaitCallback, Object)	Zatáčí metodu pro provedení do fronty a určuje objekt obsahující data, která má metoda použít. Metoda se spustí, když je k dispozici vlákno fondu vláken.
QueueUserWorkItem<TState>(Action<TState>, TState, Boolean)	Zatáčí metodu určenou delegátem Action<T> ke spuštění do fronty a poskytuje data, která má metoda použít. Metoda se spustí, když je k dispozici vlákno fondu vláken.

QueueUserWorkItem(WaitCallback)

Zdroj:: ThreadPoolWorkQueue.cs

Zdroj:: ThreadPoolWorkQueue.cs

Zdroj:: ThreadPoolWorkQueue.cs

Zatáčí metodu pro spuštění do fronty. Metoda se spustí, když je k dispozici vlákno fondu vláken.

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

A WaitCallback , který představuje metodu, která má být provedena.

Návraty

Boolean

true pokud je metoda úspěšně zařazena do fronty; NotSupportedException je vyvolán, pokud pracovní položka nemohla být zařazena do fronty.

Výjimky

ArgumentNullException

callBack je null.

NotSupportedException

Modul CLR (Common Language Runtime) je hostovaný a hostitel tuto akci nepodporuje.

Příklady

Následující příklad používá QueueUserWorkItem(WaitCallback) přetížení metody do fronty úlohy, která je reprezentována metodou ThreadProc , která se spustí, když je vlákno k dispozici. S tímto přetížením nejsou dodány žádné informace o úkolu. Informace, které jsou k dispozici pro metodu ThreadProc , jsou proto omezeny na objekt, do kterého metoda patří.

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.

Poznámky

Data vyžadovaná metodou zařazenou do fronty můžete umístit do polí instance třídy, ve které je metoda definovaná, nebo můžete použít QueueUserWorkItem(WaitCallback, Object) přetížení, které přijímá objekt obsahující potřebná data.

Poznámka

Uživatelé jazyka WaitCallback Visual Basic mohou konstruktor vynechat a jednoduše použít AddressOf operátor při předávání metody zpětného volání do QueueUserWorkItem. Visual Basic automaticky volá správný konstruktor delegáta.

Hodnota Thread.CurrentPrincipal vlastnosti se rozšíří do pracovních vláken zařazených do fronty pomocí QueueUserWorkItem metody .

Viz také

Spravovaný fond vláken

Platí pro

QueueUserWorkItem(WaitCallback, Object)

Zdroj:: ThreadPoolWorkQueue.cs

Zdroj:: ThreadPoolWorkQueue.cs

Zdroj:: ThreadPoolWorkQueue.cs

Zatáčí metodu pro provedení do fronty a určuje objekt obsahující data, která má metoda použít. Metoda se spustí, když je k dispozici vlákno fondu vláken.

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

Představující WaitCallback metodu, která se má provést.

state: Object

Objekt obsahující data, která má být použita metodou .

Návraty

Boolean

true pokud je metoda úspěšně zařazena do fronty; NotSupportedException je vyvolán, pokud pracovní položka nemohla být zařazena do fronty.

Výjimky

NotSupportedException

Modul CLR (Common Language Runtime) je hostovaný a hostitel tuto akci nepodporuje.

ArgumentNullException

callBack je null.

Příklady

Následující příklad používá fond vláken .NET k výpočtu výsledku Fibonacci pro pět čísel mezi 20 a 40. Každý Fibonacci výsledek je reprezentován Fibonacci třídou , která poskytuje metodu s názvem ThreadPoolCallback , která provádí výpočet. Vytvoří se objekt, který představuje každou Fibonacci hodnotu, a ThreadPoolCallback metoda se předá do QueueUserWorkItemobjektu , který přiřadí dostupné vlákno ve fondu pro spuštění metody .

Vzhledem k tomu, že každému Fibonacci objektu je pro výpočet přidělena polonahodná hodnota a protože každé vlákno bude soupeřit o čas procesoru, nemůžete předem vědět, jak dlouho bude trvat výpočet všech pěti výsledků. To je důvod, proč je každý Fibonacci objekt předán instanci ManualResetEvent třídy během výstavby. Každý objekt signalizuje zadaný objekt události, když je jeho výpočet dokončen, což umožňuje primární vlákno blokovat spuštění s WaitAll , dokud všech pět Fibonacci objektů vypočítat výsledek. Metoda Main pak zobrazí každý Fibonacci výsledek.

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

Poznámky

Pokud metoda zpětného volání vyžaduje komplexní data, můžete definovat třídu, která bude obsahovat data.

Poznámka

Viz také

Spravovaný fond vláken

Platí pro

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

Zdroj:: ThreadPoolWorkQueue.cs

Zdroj:: ThreadPoolWorkQueue.cs

Zdroj:: ThreadPoolWorkQueue.cs

Zatáčí metodu určenou delegátem Action<T> ke spuštění do fronty a poskytuje data, která má metoda použít. Metoda se spustí, když je k dispozici vlákno fondu vláken.

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 prvků .state

Parametry

callBack: Action<TState>

Představující Action<T> metodu, která se má provést.

state: TState

Objekt obsahující data, která má být použita metodou .

preferLocal: Boolean

true chcete-li upřednostňovat zařadit pracovní položku do fronty v blízkosti aktuálního vlákna; false , aby se pracovní položka zařadila do fronty do sdílené fronty fondu vláken.

Návraty

Boolean

true pokud je metoda úspěšně zařazena do fronty; NotSupportedException je vyvolán, pokud pracovní položka nemohla být zařazena do fronty.

Platí pro

Sdílet prostřednictvím

ThreadPool.QueueUserWorkItem Metoda

Definice

Přetížení

QueueUserWorkItem(WaitCallback)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

QueueUserWorkItem(WaitCallback, Object)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

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

Parametry typu

Parametry

Návraty

Platí pro

Další materiály