ThreadPool.QueueUserWorkItem Méthode

Définition

Espace de noms:: System.Threading

Assemblys:: netstandard.dll, System.Threading.ThreadPool.dll

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.

Met en file d’attente une méthode pour l’exécution. La méthode s’exécute lorsqu’un thread de pool de threads devient disponible.

Surcharges

Nom	Description
QueueUserWorkItem(WaitCallback)	Met en file d’attente une méthode pour l’exécution. La méthode s’exécute lorsqu’un thread de pool de threads devient disponible.
QueueUserWorkItem(WaitCallback, Object)	Met en file d’attente une méthode pour l’exécution et spécifie un objet contenant des données à utiliser par la méthode. La méthode s’exécute lorsqu’un thread de pool de threads devient disponible.
QueueUserWorkItem<TState>(Action<TState>, TState, Boolean)	Met en file d’attente une méthode spécifiée par un Action<T> délégué pour l’exécution et fournit des données à utiliser par la méthode. La méthode s’exécute lorsqu’un thread de pool de threads devient disponible.

QueueUserWorkItem(WaitCallback)

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Met en file d’attente une méthode pour l’exécution. La méthode s’exécute lorsqu’un thread de pool de threads 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

Qui WaitCallback représente la méthode à exécuter.

Retours

Boolean

true si la méthode est correctement mise en file d’attente ; NotSupportedException est levée si l’élément de travail n’a pas pu être mis 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, représentée par la ThreadProc méthode, pour s’exécuter lorsqu’un thread devient disponible. Aucune information sur les tâches 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 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 des données requises par la méthode mise en file d’attente dans les champs d’instance de la classe dans lesquelles 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.

Note

Les utilisateurs Visual Basic peuvent omettre le WaitCallback constructeur et simplement utiliser 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

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Met en file d’attente une méthode pour l’exécution et spécifie un objet contenant des données à utiliser par la méthode. La méthode s’exécute lorsqu’un thread de pool de threads 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

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

state: Object

Objet contenant des données à utiliser par la méthode.

Retours

Boolean

true si la méthode est correctement mise en file d’attente ; NotSupportedException est levée si l’élément de travail n’a pas pu être mis 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 pour cinq nombres compris entre 20 et 40. Chaque Fibonacci résultat est représenté par la Fibonacci classe, qui fournit une méthode nommée ThreadPoolCallback qui effectue le calcul. Objet qui représente chaque Fibonacci valeur est créé et la ThreadPoolCallback méthode est passée à QueueUserWorkItem, ce qui affecte un thread disponible dans le 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 est concurrent 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 Fibonacci objet est passé une instance de la classe pendant la ManualResetEvent 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 Main méthode affiche ensuite chaque Fibonacci résultat.

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.

Note

Voir aussi

Pool de threads managés

S’applique à

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

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Source:: ThreadPoolWorkQueue.cs

Met en file d’attente une méthode spécifiée par un Action<T> délégué pour l’exécution et fournit des données à utiliser par la méthode. La méthode s’exécute lorsqu’un thread de pool de threads 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

Type d’éléments de state.

Paramètres

callBack: Action<TState>

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

state: TState

Objet contenant des données à utiliser par la méthode.

preferLocal: Boolean

true pour préférer mettre en file d’attente l’élément de travail dans une file d’attente proche du thread actuel ; false pour préférer mettre en file d’attente l’élément de travail à la file d’attente partagée du pool de threads.

Retours

Boolean

true si la méthode est correctement mise en file d’attente ; NotSupportedException est levée si l’élément de travail n’a pas pu être mis en file d’attente.

S’applique à

Commentaires

Cette page a-t-elle été utile ?

Partager via

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