ThreadPool.QueueUserWorkItem Metodo
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.
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. |
- 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
true
se il metodo viene accodato correttamente. Viene generata l'eccezione NotSupportedException se non è stato possibile accodare l'elemento di lavoro.
Eccezioni
callBack
è null
.
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
Si applica a
.NET 9 e altre versioni
Prodotto | Versioni |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
- 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
true
se il metodo viene accodato correttamente. Viene generata l'eccezione NotSupportedException se non è stato possibile accodare l'elemento di lavoro.
Eccezioni
Common Language Runtime (CLR) è ospitato e l'host non supporta questa azione.
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
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.
Vedi anche
Si applica a
.NET 9 e altre versioni
Prodotto | Versioni |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
- 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
- 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
true
se il metodo viene accodato correttamente. Viene generata l'eccezione NotSupportedException se non è stato possibile accodare l'elemento di lavoro.
Si applica a
.NET 9 e altre versioni
Prodotto | Versioni |
---|---|
.NET | Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Standard | 2.1 |
Feedback su .NET
.NET è un progetto di open source. Selezionare un collegamento per fornire feedback: