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.

返回

如果此方法成功排队,则为 true;如果无法将该工作项排队,则引发 NotSupportedExceptiontrue if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

异常

callBacknullcallBack is null.

承载公共语言运行时 (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 构造函数,只需在将回调方法传递给 QueueUserWorkItem时使用 AddressOf 运算符。Visual 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 属性值将传播到使用 QueueUserWorkItem 方法排队的工作线程。In 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);
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.

返回

如果此方法成功排队,则为 true;如果无法将该工作项排队,则引发 NotSupportedExceptiontrue if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

异常

承载公共语言运行时 (CLR) 的宿主不支持此操作。The common language runtime (CLR) is hosted, and the host does not support this action.

callBacknullcallBack is null.

示例

下面的示例使用 .NET 线程池来计算介于20和40之间的五个数字的 Fibonacci 结果。The following example uses the .NET thread pool to calculate the Fibonacci result for five numbers between 20 and 40. 每个 Fibonacci 结果都由 Fibonacci 类表示,该类提供一个名为 ThreadPoolCallback 的方法,用于执行计算。Each 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 构造函数,只需在将回调方法传递给 QueueUserWorkItem时使用 AddressOf 运算符。Visual 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 属性值将传播到使用 QueueUserWorkItem 方法排队的工作线程。In 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.

返回

如果此方法成功排队,则为 true;如果无法将该工作项排队,则引发 NotSupportedExceptiontrue if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued. .

适用于