ThreadPool.QueueUserWorkItem Méthode

Référence

Définition

Espace de noms:: System.Threading

Assembly:: System.Threading.ThreadPool.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Place une méthode en file d'attente pour exécution. La méthode s'exécute lorsqu'un thread du pool devient disponible.

Surcharges

QueueUserWorkItem(WaitCallback)	Place une méthode en file d'attente pour exécution. La méthode s'exécute lorsqu'un thread du pool devient disponible.
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. La méthode s'exécute lorsqu'un thread du pool devient disponible.
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. La méthode s'exécute lorsqu'un thread du pool devient disponible.

QueueUserWorkItem(WaitCallback)

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Place une méthode en file d'attente pour exécution. La méthode s'exécute lorsqu'un thread du pool devient disponible.

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.

Retours

Boolean

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.

Exceptions

ArgumentNullException

callBack a la valeur null.

NotSupportedException

Le Common Language Runtime (CLR) est hébergé et l'hôte ne prend pas en charge cette action.

Exemples

L’exemple suivant utilise la surcharge de QueueUserWorkItem(WaitCallback) méthode pour mettre en file d’attente une tâche, qui est représentée par la ThreadProc méthode , à exécuter lorsqu’un thread devient disponible. Aucune information de tâche n’est fournie avec cette surcharge. Par conséquent, les informations disponibles pour la ThreadProc méthode sont limitées à l’objet auquel appartient la méthode.

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

Notes

Les utilisateurs Visual Basic peuvent omettre le WaitCallback constructeur et utiliser simplement l’opérateur AddressOf lors du passage de la méthode de rappel à QueueUserWorkItem. Visual Basic appelle automatiquement le constructeur délégué approprié.

La Thread.CurrentPrincipal valeur de propriété est propagée aux threads de travail mis en file d’attente à l’aide de la QueueUserWorkItem méthode .

Voir aussi

Pool de threads managés

S’applique à

QueueUserWorkItem(WaitCallback, Object)

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

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. La méthode s'exécute lorsqu'un thread du pool devient disponible.

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

Paramètres

callBack: WaitCallback

WaitCallback représentant la méthode à exécuter.

state: Object

Objet contenant les données que la méthode doit utiliser.

Retours

Boolean

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.

Exceptions

NotSupportedException

Le Common Language Runtime (CLR) est hébergé et l'hôte ne prend pas en charge cette action.

ArgumentNullException

callBack a la valeur null.

Exemples

L’exemple suivant utilise le pool de threads .NET pour calculer le Fibonacci résultat de cinq nombres compris entre 20 et 40. Chaque résultat Fibonacci est représenté par la classe Fibonacci, qui fournit une méthode nommée ThreadPoolCallback qui effectue le calcul. 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.

Étant donné que chaque Fibonacci objet reçoit une valeur semi-aléatoire à calculer et que chaque thread sera en concurrence pour le temps processeur, vous ne pouvez pas savoir à l’avance combien de temps il faudra pour calculer les cinq résultats. C’est pourquoi chaque objet Fibonacci reçoit une instance de la classe ManualResetEvent pendant la construction. Chaque objet signale l’objet d’événement fourni lorsque son calcul est terminé, ce qui permet au thread principal de bloquer l’exécution jusqu’à WaitAll ce que les cinq Fibonacci objets aient calculé un résultat. La méthode Main affiche ensuite chaque résultat Fibonacci.

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 nécessite des données complexes, vous pouvez définir une classe pour contenir les données.

Notes

Voir aussi

Pool de threads managés

S’applique à

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

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

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. La méthode s'exécute lorsqu'un thread du pool devient disponible.

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.

Paramètres

callBack: Action<TState>

Action<T> représentant la méthode à exécuter.

state: TState

Objet contenant les données que la méthode doit utiliser.

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.

Retours

Boolean

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.

S’applique à

ThreadPool.QueueUserWorkItem Méthode

Définition

Surcharges

QueueUserWorkItem(WaitCallback)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

QueueUserWorkItem(WaitCallback, Object)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

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

Paramètres de type

Paramètres

Retours

S’applique à

Commentaires

Ressources supplémentaires