ThreadPool.QueueUserWorkItem Metoda

Definice

Obor názvů:

System.Threading

Sestavení:

netstandard.dll, System.Threading.ThreadPool.dll

Zařadí metodu spuštění do fronty. Metoda se spustí, když bude k dispozici vlákno fondu vláken.

Přetížení

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

QueueUserWorkItem(WaitCallback)

Zdroj:

ThreadPoolWorkQueue.cs

Zařadí metodu spuštění do fronty. Metoda se spustí, když bude 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á se má provést.

Návraty

Boolean

true pokud je metoda úspěšně zařazena do fronty; NotSupportedException je vyvolán, pokud pracovní položku nelze zařadit do fronty.

Výjimky

ArgumentNullException

callBack je null.

NotSupportedException

Je hostovaný modul CLR (Common Language Runtime) 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 , provést, když je vlákno k dispozici. S tímto přetížením nejsou zadány žádné informace o úkolu. Proto informace, které jsou k dispozici pro metodu ThreadProc , jsou omezeny na objekt, do kterého metoda patří.

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 ve frontě můžete umístit do polí instance třídy, ve které je metoda definována, 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 vynechat konstruktor a jednoduše použít AddressOf operátor při předá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é

• Fond spravovaných vláken

QueueUserWorkItem(WaitCallback, Object)

Zdroj:

ThreadPoolWorkQueue.cs

Zařadí do fronty metodu pro spuštění a určuje objekt obsahující data, která má metoda použít. Metoda se spustí, když bude 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);

static member QueueUserWorkItem : System.Threading.WaitCallback * obj -> bool

Public Shared Function QueueUserWorkItem (callBack As WaitCallback, state As Object) As Boolean

Parametry

callBack

WaitCallback

Představuje WaitCallback metodu, která se má provést.

state

Object

Objekt obsahující data, která se mají použít metodou.

Návraty

Boolean

true pokud je metoda úspěšně zařazena do fronty; NotSupportedException je vyvolán, pokud pracovní položku nelze zařadit do fronty.

Výjimky

NotSupportedException

Je hostovaný modul CLR (Common Language Runtime) 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 pěti čí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. Objekt, který představuje každou Fibonacci hodnotu je vytvořena a metoda je předána ThreadPoolCallbackQueueUserWorkItem, který přiřadí dostupné vlákno ve fondu ke spuštění metody.

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

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 složitá data, můžete definovat třídu, která bude obsahovat data.

Poznámka:

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

Viz také

• Fond spravovaných vláken

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

Zdroj:

ThreadPoolWorkQueue.cs

Zařadí metodu určenou delegátem Action<T> pro spuštění a poskytuje data, která tato metoda použije. Metoda se spustí, když bude 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ředstavuje Action<T> metodu, která se má provést.

state

TState

Objekt obsahující data, která se mají použít metodou.

preferLocal

Boolean

true preferovat frontu pracovní položky ve frontě blízko aktuálního vlákna; false upřednostňovat frontu pracovní položky 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žku nelze zařadit do fronty.