ThreadPool.QueueUserWorkItem Metodo

Definizione

Spazio dei nomi:: System.Threading

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

Assembly:: System.Threading.ThreadPool.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Accoda un metodo per l'esecuzione. Il metodo viene eseguito quando diventa disponibile un thread del pool di thread.

Overload

Nome	Descrizione
QueueUserWorkItem(WaitCallback)	Accoda un metodo per l'esecuzione. Il metodo viene eseguito quando diventa disponibile un thread del pool di thread.
QueueUserWorkItem(WaitCallback, Object)	Accoda un metodo per l'esecuzione e specifica un oggetto contenente dati da utilizzare dal metodo . Il metodo viene eseguito quando diventa disponibile un thread del pool di thread.
QueueUserWorkItem<TState>(Action<TState>, TState, Boolean)	Accoda un metodo specificato da un Action<T> delegato per l'esecuzione e fornisce i dati da usare dal metodo . Il metodo viene eseguito quando diventa disponibile un thread del pool di thread.

QueueUserWorkItem(WaitCallback)

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Accoda un metodo per l'esecuzione. Il metodo viene eseguito quando diventa disponibile un thread del pool di thread.

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

Parametri

callBack: WaitCallback

Oggetto WaitCallback che rappresenta il metodo da eseguire.

Restituisce

Boolean

true se il metodo viene accodato correttamente; NotSupportedException viene generata se non è stato possibile accodare l'elemento di lavoro.

Eccezioni

ArgumentNullException

callBack è null.

NotSupportedException

Common Language Runtime (CLR) è ospitato e l'host non supporta questa azione.

Esempio

Nell'esempio seguente viene usato l'overload del QueueUserWorkItem(WaitCallback) metodo per accodare un'attività, rappresentata dal ThreadProc metodo , da eseguire quando un thread diventa disponibile. Nessuna informazione sull'attività viene fornita con questo overload. Di conseguenza, le informazioni disponibili per il ThreadProc metodo sono limitate all'oggetto a cui appartiene il metodo .

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.

Commenti

È possibile inserire i dati richiesti dal metodo in coda nei campi dell'istanza della classe in cui è definito il metodo oppure è possibile utilizzare l'overload QueueUserWorkItem(WaitCallback, Object) che accetta un oggetto contenente i dati necessari.

Annotazioni

Gli utenti di Visual Basic possono omettere il WaitCallback costruttore e usare semplicemente l'operatore AddressOf quando si passa il metodo di callback a QueueUserWorkItem. Visual Basic chiama automaticamente il costruttore delegato corretto.

Il valore della Thread.CurrentPrincipal proprietà viene propagato ai thread di lavoro accodati usando il QueueUserWorkItem metodo .

Vedi anche

Pool di thread gestiti

Si applica a

QueueUserWorkItem(WaitCallback, Object)

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Accoda un metodo per l'esecuzione e specifica un oggetto contenente dati da utilizzare dal metodo . Il metodo viene eseguito quando diventa disponibile un thread del pool di thread.

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

Parametri

callBack: WaitCallback

Oggetto WaitCallback che rappresenta il metodo da eseguire.

state: Object

Oggetto contenente dati da utilizzare dal metodo .

Restituisce

Boolean

true se il metodo viene accodato correttamente; NotSupportedException viene generata se non è stato possibile accodare l'elemento di lavoro.

Eccezioni

NotSupportedException

Common Language Runtime (CLR) è ospitato e l'host non supporta questa azione.

ArgumentNullException

callBack è null.

Esempio

Nell'esempio seguente viene usato il pool di thread .NET per calcolare il Fibonacci risultato per cinque numeri compresi tra 20 e 40. Ogni Fibonacci risultato è rappresentato dalla Fibonacci classe , che fornisce un metodo denominato ThreadPoolCallback che esegue il calcolo. Oggetto che rappresenta ogni Fibonacci valore viene creato e il ThreadPoolCallback metodo viene passato a QueueUserWorkItem, che assegna un thread disponibile nel pool per eseguire il metodo .

Poiché a ogni Fibonacci oggetto viene assegnato un valore semi-casuale da calcolare e poiché ogni thread sarà in competizione per il tempo del processore, non è possibile sapere in anticipo per quanto tempo sarà necessario per calcolare tutti e cinque i risultati. Ecco perché ogni Fibonacci oggetto viene passato a un'istanza della classe durante la ManualResetEvent costruzione. Ogni oggetto segnala l'oggetto evento fornito al termine del calcolo, che consente al thread primario di bloccare l'esecuzione con WaitAll finché tutti e cinque Fibonacci gli oggetti non hanno calcolato un risultato. Il Main metodo visualizza quindi ogni Fibonacci risultato.

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

Commenti

Se il metodo di callback richiede dati complessi, è possibile definire una classe per contenere i dati.

Annotazioni

Vedi anche

Pool di thread gestiti

Si applica a

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

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Accoda un metodo specificato da un Action<T> delegato per l'esecuzione e fornisce i dati da usare dal metodo . Il metodo viene eseguito quando diventa disponibile un thread del pool di thread.

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

Parametri di tipo

TState

Tipo di elementi di state.

Parametri

callBack: Action<TState>

Oggetto Action<T> che rappresenta il metodo da eseguire.

state: TState

Oggetto contenente dati da utilizzare dal metodo .

preferLocal: Boolean

true per preferire la coda dell'elemento di lavoro in una coda vicina al thread corrente; false per preferire la coda dell'elemento di lavoro alla coda condivisa del pool di thread.

Restituisce

Boolean

true se il metodo viene accodato correttamente; NotSupportedException viene generata se non è stato possibile accodare l'elemento di lavoro.

Si applica a

Commenti e suggerimenti

Questa pagina è stata utile?

Condividi tramite

ThreadPool.QueueUserWorkItem Metodo

Definizione

Overload

QueueUserWorkItem(WaitCallback)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

QueueUserWorkItem(WaitCallback, Object)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

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

Parametri di tipo

Parametri

Restituisce

Si applica a

Commenti e suggerimenti