ThreadPool.QueueUserWorkItem Méthode

Définition

Place une méthode en file d'attente pour exécution.Queues a method for execution. La méthode s'exécute lorsqu'un thread du pool devient disponible.The method executes when a thread pool thread becomes available.

Surcharges

QueueUserWorkItem(WaitCallback)

Place une méthode en file d'attente pour exécution.Queues a method for execution. La méthode s'exécute lorsqu'un thread du pool devient disponible.The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback, Object)

Place une méthode en file d'attente pour exécution et spécifie un objet contenant les données que la méthode doit utiliser.Queues a method for execution, and specifies an object containing data to be used by the method. La méthode s'exécute lorsqu'un thread du pool devient disponible.The method executes when a thread pool thread becomes available.

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

Place en file d'attente une méthode spécifiée par un délégué Action<T> pour exécution et fournit les données que la méthode doit utiliser.Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. La méthode s'exécute lorsqu'un thread du pool devient disponible.The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback)

Place une méthode en file d'attente pour exécution.Queues a method for execution. La méthode s'exécute lorsqu'un thread du pool devient disponible.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

Paramètres

callBack
WaitCallback

WaitCallback qui représente la méthode à exécuter.A WaitCallback that represents the method to be executed.

Retours

true si la méthode est placée en file d'attente avec succès ; NotSupportedException est levé si l'élément de travail n'a pas pu être placé en file d'attente.true if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

Exceptions

callBack a la valeur null.callBack is null.

Le Common Language Runtime (CLR) est hébergé et l'hôte ne prend pas en charge cette action.The common language runtime (CLR) is hosted, and the host does not support this action.

Exemples

L’exemple suivant utilise la surcharge de méthode QueueUserWorkItem(WaitCallback) pour la mise en file d’attente d’une tâche, qui est représentée par la méthode ThreadProc, pour s’exécuter quand un thread devient disponible.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. Aucune information de tâche n’est fournie avec cette surcharge.No task information is supplied with this overload. Par conséquent, les informations qui sont disponibles pour la méthode ThreadProc sont limitées à l’objet auquel la méthode appartient.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.

Remarques

Vous pouvez placer les données requises par la méthode en file d’attente dans les champs d’instance de la classe dans laquelle la méthode est définie, ou vous pouvez utiliser la surcharge QueueUserWorkItem(WaitCallback, Object) qui accepte un objet contenant les données nécessaires.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.

Notes

Visual Basic utilisateurs peuvent omettre le constructeur WaitCallback et simplement utiliser l’opérateur AddressOf lors du passage de la méthode de rappel à QueueUserWorkItem.Visual Basic users can omit the WaitCallback constructor, and simply use the AddressOf operator when passing the callback method to QueueUserWorkItem. Visual Basic appelle automatiquement le constructeur délégué approprié.Visual Basic automatically calls the correct delegate constructor.

Informations sur la versionVersion Information

Dans la version de .NET Framework 2,0, la valeur de la propriété Thread.CurrentPrincipal est propagée aux threads de travail mis en file d’attente à l’aide de la méthode QueueUserWorkItem.In the .NET Framework version 2.0, the Thread.CurrentPrincipal property value is propagated to worker threads queued using the QueueUserWorkItem method. Dans les versions antérieures, les informations de principal ne sont pas propagées.In earlier versions, the principal information is not propagated.

Voir aussi

QueueUserWorkItem(WaitCallback, Object)

Place une méthode en file d'attente pour exécution et spécifie un objet contenant les données que la méthode doit utiliser.Queues a method for execution, and specifies an object containing data to be used by the method. La méthode s'exécute lorsqu'un thread du pool devient disponible.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

Paramètres

callBack
WaitCallback

WaitCallback représentant la méthode à exécuter.A WaitCallback representing the method to execute.

state
Object

Objet contenant les données que la méthode doit utiliser.An object containing data to be used by the method.

Retours

true si la méthode est placée en file d'attente avec succès ; NotSupportedException est levé si l'élément de travail n'a pas pu être placé en file d'attente.true if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued.

Exceptions

Le Common Language Runtime (CLR) est hébergé et l'hôte ne prend pas en charge cette action.The common language runtime (CLR) is hosted, and the host does not support this action.

callBack a la valeur null.callBack is null.

Exemples

L’exemple suivant utilise le pool de threads .NET pour calculer le résultat de la Fibonacci pour cinq nombres compris entre 20 et 40.The following example uses the .NET thread pool to calculate the Fibonacci result for five numbers between 20 and 40. Chaque résultat Fibonacci est représenté par la classe Fibonacci, qui fournit une méthode nommée ThreadPoolCallback qui effectue le calcul.Each Fibonacci result is represented by the Fibonacci class, which provides a method named ThreadPoolCallback that performs the calculation. Un objet représentant chaque valeur Fibonacci est créé, et la méthode ThreadPoolCallback est passée à QueueUserWorkItem, qui assigne un thread disponible du pool pour exécuter la méthode.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.

Étant donné que chaque objet Fibonacci reçoit une valeur semi-aléatoire à calculer et que chaque thread est en concurrence pour le temps processeur, vous ne pouvez pas savoir à l’avance la durée nécessaire pour calculer les cinq résultats.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. C’est pourquoi chaque objet Fibonacci reçoit une instance de la classe ManualResetEvent pendant la construction.That is why each Fibonacci object is passed an instance of the ManualResetEvent class during construction. Chaque objet signale l’objet d’événement fourni quand son calcul est terminé, ce qui permet au thread principal de bloquer l’exécution avec WaitAll jusqu’à ce que les cinq objets Fibonacci aient calculé un résultat.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. La méthode Main affiche ensuite chaque résultat 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

Remarques

Si la méthode de rappel requiert des données complexes, vous pouvez définir une classe pour contenir les données.If the callback method requires complex data, you can define a class to contain the data.

Notes

Visual Basic utilisateurs peuvent omettre le constructeur WaitCallback et simplement utiliser l’opérateur AddressOf lors du passage de la méthode de rappel à QueueUserWorkItem.Visual Basic users can omit the WaitCallback constructor, and simply use the AddressOf operator when passing the callback method to QueueUserWorkItem. Visual Basic appelle automatiquement le constructeur délégué approprié.Visual Basic automatically calls the correct delegate constructor.

Informations sur la versionVersion Information

Dans la version de .NET Framework 2,0, la valeur de la propriété Thread.CurrentPrincipal est propagée aux threads de travail mis en file d’attente à l’aide de la méthode QueueUserWorkItem.In the .NET Framework version 2.0, the Thread.CurrentPrincipal property value is propagated to worker threads queued using the QueueUserWorkItem method. Dans les versions antérieures, les informations de principal ne sont pas propagées.In earlier versions, the principal information is not propagated.

Voir aussi

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

Place en file d'attente une méthode spécifiée par un délégué Action<T> pour exécution et fournit les données que la méthode doit utiliser.Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. La méthode s'exécute lorsqu'un thread du pool devient disponible.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

Paramètres de type

TState

Le type des éléments de state.The type of elements of state.

Paramètres

callBack
Action<TState>

Action<T> représentant la méthode à exécuter.An Action<T> representing the method to execute.

state
TState

Objet contenant les données que la méthode doit utiliser.An object containing data to be used by the method.

preferLocal
Boolean

true pour placer l’élément de travail dans une file d’attente à proximité du thread actuel ; false pour placer l’élément de travail dans la file d’attente partagée du pool de threads.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.

Retours

true si la méthode est placée en file d'attente avec succès ; NotSupportedException est levé si l'élément de travail n'a pas pu être placé en file d'attente.true if the method is successfully queued; NotSupportedException is thrown if the work item could not be queued. ..

S’applique à