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이고, 작업 항목을 큐에 대기할 수 없으면 NotSupportedException이 throw됩니다.true if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

예외

callBack이(가) null인 경우.callBack 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 생성자를 생략할 수 있으며, AddressOf 콜백 메서드를에 전달 하는 경우에만 연산자를 사용 QueueUserWorkItem 합니다.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);
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이고, 작업 항목을 큐에 대기할 수 없으면 NotSupportedException이 throw됩니다.true 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.

callBack이(가) null인 경우.callBack is null.

예제

다음 예제에서는 .NET 스레드 풀을 사용 하 여 Fibonacci 20에서 40 사이의 5 개 숫자에 대 한 결과를 계산 합니다.The following example uses the .NET thread pool to calculate the Fibonacci result for five numbers between 20 and 40. Fibonacci 결과는 계산을 수행하는 ThreadPoolCallback이라는 메서드를 제공하는 Fibonacci 클래스로 표현됩니다.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 개체에는 계산을 위한 세미 난수 값이 지정 되 고 각 스레드는 프로세서 시간에 대해 경쟁 하므로 5 개 결과를 모두 계산 하기 위해 소요 되는 시간을 미리 알 수 없습니다.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 5 개의 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 콜백 메서드를에 전달 하는 경우에만 연산자를 사용 QueueUserWorkItem 합니다.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.

반환

Boolean

메서드가 성공적으로 큐에 대기되면 true이고, 작업 항목을 큐에 대기할 수 없으면 NotSupportedException이 throw됩니다.true if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

적용 대상