ThreadPool.QueueUserWorkItem 方法

定義

將方法排入佇列,以等候執行。Queues a method for execution. 可以使用執行緒集區執行緒時,即可執行這個方法。The method executes when a thread pool thread becomes available.

多載

QueueUserWorkItem(WaitCallback)

將方法排入佇列,以等候執行。Queues a method for execution. 可以使用執行緒集區執行緒時,即可執行這個方法。The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback, Object)

將方法排入佇列,以等候執行,並指定包含這個方法所要使用之資料的物件。Queues a method for execution, and specifies an object containing data to be used by the method. 可以使用執行緒集區執行緒時,即可執行這個方法。The method executes when a thread pool thread becomes available.

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

Action<T> 委派指定的方法排入佇列以便執行,並提供將由方法使用的資料。Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. 可以使用執行緒集區執行緒時,即可執行這個方法。The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback)

將方法排入佇列,以等候執行。Queues a method for execution. 可以使用執行緒集區執行緒時,即可執行這個方法。The method executes when a thread pool thread becomes available.

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

參數

callBack
WaitCallback

WaitCallback,代表要執行的方法。A WaitCallback that represents the method to be executed.

傳回

Boolean

如果方法成功佇列則為 true;如果工作項目無法佇列則會擲回 NotSupportedExceptiontrue if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

例外狀況

callBacknullcallBack is null.

Common Language Runtime (CLR) 已裝載,而且主機不支援這個動作。The common language runtime (CLR) is hosted, and the host does not support this action.

範例

下列範例會使用方法多載來將工作 QueueUserWorkItem(WaitCallback) (由方法表示)排入佇列, ThreadProc 以線上程變成可用時執行。The following example uses the QueueUserWorkItem(WaitCallback) method overload to queue a task, which is represented by the ThreadProc method, to execute when a thread becomes available. 未提供此多載的工作資訊。No task information is supplied with this overload. 因此,方法可用的資訊 ThreadProc 會限制為該方法所屬的物件。Therefore, the information that is available to the ThreadProc method is limited to the object the method belongs to.

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.

備註

您可以將已排入佇列的方法所需的資料放在定義方法之類別的實例欄位中,或者,您可以使用可 QueueUserWorkItem(WaitCallback, Object) 接受包含所需資料之物件的多載。You can place data required by the queued method in the instance fields of the class in which the method is defined, or you can use the QueueUserWorkItem(WaitCallback, Object) overload that accepts an object containing the necessary data.

注意

Visual Basic 使用者可以省略此 WaitCallback 函式,並在將 AddressOf 回呼方法傳遞給時,直接使用運算子 QueueUserWorkItemVisual Basic users can omit the WaitCallback constructor, and simply use the AddressOf operator when passing the callback method to QueueUserWorkItem. Visual Basic 會自動呼叫正確的委派函式。Visual Basic automatically calls the correct delegate constructor.

版本資訊Version Information

在 .NET Framework 2.0 版中, Thread.CurrentPrincipal 會使用方法將屬性值傳播至已排入佇列的背景工作執行緒 QueueUserWorkItemIn the .NET Framework version 2.0, the Thread.CurrentPrincipal property value is propagated to worker threads queued using the QueueUserWorkItem method. 在較舊的版本中,不會傳播主體資訊。In earlier versions, the principal information is not propagated.

另請參閱

適用於

QueueUserWorkItem(WaitCallback, Object)

將方法排入佇列,以等候執行,並指定包含這個方法所要使用之資料的物件。Queues a method for execution, and specifies an object containing data to be used by the method. 可以使用執行緒集區執行緒時,即可執行這個方法。The method executes when a thread pool thread becomes available.

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

參數

callBack
WaitCallback

WaitCallback,代表要執行的方法。A WaitCallback representing the method to execute.

state
Object

物件,包含這個方法所要使用的資料。An object containing data to be used by the method.

傳回

Boolean

如果方法成功佇列則為 true;如果工作項目無法佇列則會擲回 NotSupportedExceptiontrue if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

例外狀況

Common Language Runtime (CLR) 已裝載,而且主機不支援這個動作。The common language runtime (CLR) is hosted, and the host does not support this action.

callBacknullcallBack is null.

範例

下列範例會使用 .NET 執行緒集區來計算 Fibonacci 20 到40之間五個數字的結果。The following example uses the .NET thread pool to calculate the Fibonacci result for five numbers between 20 and 40. 每個 Fibonacci 結果都會以 Fibonacci 類別表示,該類別提供一個執行計算的方法,稱為 ThreadPoolCallbackEach Fibonacci result is represented by the Fibonacci class, which provides a method named ThreadPoolCallback that performs the calculation. 這會建立代表每個 Fibonacci 值的物件,並將 ThreadPoolCallback 方法傳遞至 QueueUserWorkItem,以指派集區中的可用執行緒來執行此方法。An object that represents each Fibonacci value is created, and the ThreadPoolCallback method is passed to QueueUserWorkItem, which assigns an available thread in the pool to execute the method.

因為每個 Fibonacci 物件都有一個半隨機值來計算,而且每個執行緒都會競爭處理器時間,所以您無法事先知道計算這五個結果所需的時間。Because each Fibonacci object is given a semi-random value to compute, and because each thread will be competing for processor time, you cannot know in advance how long it will take for all five results to be calculated. 這就是為什麼會在建構期間將每個 Fibonacci 物件傳遞至 ManualResetEvent 類別的執行個體。That is why each Fibonacci object is passed an instance of the ManualResetEvent class during construction. 每個物件會在其計算完成時表示所提供的事件物件,這可讓主要執行緒封鎖執行, WaitAll 直到全部五個 Fibonacci 物件都已計算結果為止。Each object signals the provided event object when its calculation is complete, which allows the primary thread to block execution with WaitAll until all five Fibonacci objects have calculated a result. Main 方法接著會顯示每個 Fibonacci 結果。The Main method then displays each Fibonacci result.

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

備註

如果回呼方法需要複雜的資料,您可以定義要包含資料的類別。If the callback method requires complex data, you can define a class to contain the data.

注意

Visual Basic 使用者可以省略此 WaitCallback 函式,並在將 AddressOf 回呼方法傳遞給時,直接使用運算子 QueueUserWorkItemVisual Basic users can omit the WaitCallback constructor, and simply use the AddressOf operator when passing the callback method to QueueUserWorkItem. Visual Basic 會自動呼叫正確的委派函式。Visual Basic automatically calls the correct delegate constructor.

版本資訊Version Information

在 .NET Framework 2.0 版中, Thread.CurrentPrincipal 會使用方法將屬性值傳播至已排入佇列的背景工作執行緒 QueueUserWorkItemIn the .NET Framework version 2.0, the Thread.CurrentPrincipal property value is propagated to worker threads queued using the QueueUserWorkItem method. 在較舊的版本中,不會傳播主體資訊。In earlier versions, the principal information is not propagated.

另請參閱

適用於

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

Action<T> 委派指定的方法排入佇列以便執行,並提供將由方法使用的資料。Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. 可以使用執行緒集區執行緒時,即可執行這個方法。The method executes when a thread pool thread becomes available.

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

類型參數

TState

state 項目的類型。The type of elements of state.

參數

callBack
Action<TState>

Action<T>,代表要執行的方法。An Action<T> representing the method to execute.

state
TState

物件,包含這個方法所要使用的資料。An object containing data to be used by the method.

preferLocal
Boolean

true 以偏好將佇列中工作項目排入接近目前執行緒的佇列;false 以偏好將工作項目排入執行緒集區的共用佇列。true to prefer queueing the work item in a queue close to the current thread; false to prefer queueing the work item to the thread pool's shared queue.

傳回

Boolean

如果方法成功佇列則為 true;如果工作項目無法佇列則會擲回 NotSupportedExceptiontrue if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

適用於