ThreadPool.QueueUserWorkItem Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Threading

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 da eseguire. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.

Overload

QueueUserWorkItem(WaitCallback)	Accoda un metodo da eseguire. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.
QueueUserWorkItem(WaitCallback, Object)	Accoda un metodo da eseguire e specifica un oggetto che contiene i dati che dovranno essere usati dal metodo. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.
QueueUserWorkItem<TState>(Action<TState>, TState, Boolean)	Accoda un metodo specificato da un delegato Action<T> per l'esecuzione e fornisce i dati che devono essere usati dal metodo. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.

QueueUserWorkItem(WaitCallback)

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Accoda un metodo da eseguire. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.

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. Viene generata l'eccezione NotSupportedException 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 utilizzato 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 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.

Commenti

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

Nota

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

Accoda un metodo da eseguire e specifica un oggetto che contiene i dati che dovranno essere usati dal metodo. Il metodo viene eseguito quando un thread del pool di thread diventa disponibile.

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

WaitCallback che rappresenta il metodo da eseguire.

state: Object

Oggetto contenente i dati che devono essere usati dal metodo.

Restituisce

Boolean

true se il metodo viene accodato correttamente. Viene generata l'eccezione NotSupportedException 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 risultato di Fibonacci viene rappresentato dalla classe Fibonacci, che fornisce un metodo denominato ThreadPoolCallback per l'esecuzione del calcolo. Viene creato un oggetto che rappresenta ogni valore Fibonacci, il metodo ThreadPoolCallback viene passato a QueueUserWorkItem, che assegna un thread disponibile del 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 quanto tempo richiederà per calcolare tutti e cinque i risultati. Per questo motivo a ogni oggetto Fibonacci viene passata un'istanza della classe ManualResetEvent durante la costruzione. Ogni oggetto segnala l'oggetto evento fornito al termine del calcolo, che consente al thread primario di bloccare l'esecuzione con WaitAll fino a quando tutti e cinque Fibonacci gli oggetti non hanno calcolato un risultato. Il metodo Main visualizza quindi ogni risultato 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

Commenti

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

Nota

Vedi anche

Pool di thread gestiti

Si applica a

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

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

Origine:: ThreadPoolWorkQueue.cs

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

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 degli elementi di state.

Parametri

callBack: Action<TState>

Action<T> che rappresenta il metodo da eseguire.

state: TState

Oggetto contenente i dati che devono essere usati dal metodo.

preferLocal: Boolean

true per preferire l'accodamento dell'elemento di lavoro in una coda vicino al thread corrente; false per preferire l'accodamento dell'elemento di lavoro nella coda condivisa del pool di thread.

Restituisce

Boolean

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

Si applica a

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

Risorse aggiuntive