ThreadPool Klasse

Definition

Namespace:

System.Threading

Assembly:

System.Threading.ThreadPool.dll

Quelle:

ThreadPool.CoreCLR.cs

Stellt einen Threadpool bereit, der verwendet werden kann, um Aufgaben auszuführen, Arbeitselemente bereitzustellen, asynchrone E/A zu verarbeiten, im Auftrag anderer Threads zu warten und Zeitgeber zu verarbeiten.

public ref class ThreadPool abstract sealed

public static class ThreadPool

type ThreadPool = class

Public Class ThreadPool

Vererbung

Object

ThreadPool

Beispiele

Im folgenden Beispiel stellt der Hauptanwendungsthread eine Methode mit dem Namen ThreadProc für die Ausführung in einem Threadpoolthread in die Warteschlange, schläft eine Sekunde lang und wird dann beendet. Die ThreadProc -Methode zeigt einfach eine Meldung an.

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.

Wenn Sie den Aufruf der Thread.Sleep -Methode auskommentieren, wird der Hauptthread beendet, bevor die Methode im Threadpoolthread ausgeführt wird. Der Threadpool verwendet Hintergrundthreads, die die Anwendung nicht laufen lassen, wenn alle Vordergrundthreads beendet wurden. (Dies ist ein einfaches Beispiel für eine Racebedingung.)

Hinweise

Viele Anwendungen erstellen Threads, die viel Zeit im Ruhezustand verbringen und auf ein Ereignis warten. Andere Threads können nur in einen Ruhezustand versetzt werden, um regelmäßig aktiviert zu werden, um nach Änderungs- oder Aktualisierungsstatusinformationen abzufragen. Mit dem Threadpool können Sie Threads effizienter verwenden, indem Sie Ihrer Anwendung einen Pool von Workerthreads bereitstellen, die vom System verwaltet werden. Beispiele für Vorgänge, die Threadpoolthreads verwenden:

• Wenn Sie ein Task - oder Task<TResult> -Objekt erstellen, um eine Aufgabe asynchron auszuführen, ist standardmäßig die Ausführung der Aufgabe in einem Threadpoolthread geplant.

• Asynchrone Timer verwenden den Threadpool. Threadpoolthreads führen Rückrufe aus der System.Threading.Timer -Klasse aus und lösen Ereignisse aus der System.Timers.Timer -Klasse aus.

• Wenn Sie registrierte Wartehandles verwenden, überwacht ein Systemthread den Status der Wartehandles. Wenn ein Wartevorgang abgeschlossen ist, führt ein Workerthread aus dem Threadpool die entsprechende Rückruffunktion aus.

• Wenn Sie die QueueUserWorkItem -Methode aufrufen, um eine Methode für die Ausführung in einem Threadpoolthread in die Warteschlange zu stellen. Hierzu übergeben Sie der Methode einen WaitCallback Delegaten. Der Delegat verfügt über die Signatur.

  void WaitCallback(Object state)
  

  Sub WaitCallback(state As Object)
  

  wobei state ein Objekt ist, das Daten enthält, die vom Delegaten verwendet werden sollen. Die tatsächlichen Daten können durch Aufrufen der -Methode an den QueueUserWorkItem(WaitCallback, Object) Delegaten übergeben werden.

Hinweis

Die Threads im verwalteten Threadpool sind Hintergrundthreads. Das heißt, ihre IsBackground Eigenschaften sind true. Dies bedeutet, dass ein ThreadPool Thread eine Anwendung nicht mehr ausführt, nachdem alle Vordergrundthreads beendet wurden.

Wichtig

Wenn der Threadpool einen Thread wiederverwendet, werden die Daten nicht im lokalen Threadspeicher oder in Feldern gelöscht, die mit dem ThreadStaticAttribute Attribut gekennzeichnet sind. Wenn eine Methode daher den lokalen Threadspeicher oder felder untersucht, die mit dem ThreadStaticAttribute Attribut gekennzeichnet sind, können die gefundenen Werte von einer früheren Verwendung des Threadpoolthreads übrig bleiben.

Sie können auch Arbeitselemente, die sich nicht auf einen Wartevorgang beziehen, mit dem Threadpool in die Warteschlange stellen. Um anzufordern, dass ein Arbeitselement von einem Thread im Threadpool behandelt wird, rufen Sie die -Methode auf QueueUserWorkItem . Diese Methode verwendet als Parameter einen Verweis auf die Methode oder den Delegaten, der von dem aus dem Threadpool ausgewählten Thread aufgerufen wird. Es gibt keine Möglichkeit, ein Arbeitselement abzubrechen, nachdem es in die Warteschlange gestellt wurde.

Timer-Warteschlangen-Timer und registrierte Wartevorgänge verwenden auch den Threadpool. Ihre Rückruffunktionen werden im Threadpool in die Warteschlange eingereiht.

Pro Prozess gibt es einen Threadpool. Ab .NET Framework 4 ist die Standardgröße des Threadpools für einen Prozess von mehreren Faktoren abhängig, z.B. von der Größe des virtuellen Adressraums. Ein Prozess kann die GetMaxThreads-Methode aufrufen, um die Anzahl der Threads zu bestimmen. Die Anzahl der Threads im Threadpool kann mithilfe der SetMaxThreads -Methode geändert werden. Jeder Thread verwendet die Standardstapelgröße und wird mit der Standardpriorität ausgeführt.

Hinweis

Nicht verwalteter Code, der die .NET Framework hostet, kann die Größe des Threadpools mithilfe der in der CorSetMaxThreads Datei mscoree.h definierten Funktion ändern.

Der Threadpool stellt bei Bedarf neue Workerthreads oder E/A-Vervollständigungsthreads bereit, bis er das Maximum für jede Kategorie erreicht. Wenn ein Maximum erreicht ist, kann der Threadpool zusätzliche Threads in dieser Kategorie erstellen oder warten, bis einige Aufgaben abgeschlossen sind. Ab .NET Framework 4 erstellt und zerstört der Threadpool Arbeitsthreads, um den Durchsatz zu optimieren. Der Durchsatz ist als die Anzahl der Aufgaben definiert, die pro Zeiteinheit abgeschlossen werden. Bei zu wenigen Threads werden die verfügbaren Ressourcen möglicherweise nicht optimal genutzt, wohingegen bei zu vielen Threads Ressourcenkonflikte auftreten können.

Hinweis

Wenn die Anforderungen niedrig sind, kann die tatsächliche Anzahl der Threads im Threadpool unterhalb der Mindestwerte liegen.

Sie können die GetMinThreads-Methode verwenden, um diese Mindestwerte abzurufen.

Achtung

Sie können die SetMinThreads -Methode verwenden, um die Mindestanzahl von Threads zu erhöhen. Allerdings kann ein unnötiges Erhöhen dieses Wertes zu Leistungsproblemen führen. Wenn zu viele Aufgaben gleichzeitig gestartet werden, werden möglicherweise alle Aufgaben zu langsam ausgeführt. In den meisten Fällen erreicht der Threadpool mit dem eigenen Algorithmus für die Zuordnung von Threads eine bessere Leistung.

Eigenschaften

CompletedWorkItemCount	Ruft die Anzahl der Arbeitselemente ab, die bisher verarbeitet wurden.
PendingWorkItemCount	Ruft die Anzahl von Arbeitselementen ab, die sich derzeit in der Verarbeitungswarteschlange befinden.
ThreadCount	Ruft die Anzahl der derzeit vorhandenen Threads im Threadpool ab.

Methoden

BindHandle(IntPtr)	Veraltet. Bindet ein Betriebssystemhandle an den ThreadPool.
BindHandle(SafeHandle)	Bindet ein Betriebssystemhandle an den ThreadPool.
GetAvailableThreads(Int32, Int32)	Ruft die Differenz zwischen der von der GetMaxThreads(Int32, Int32)-Methode zurückgegebenen maximalen Anzahl der Threads im Threadpool und der Anzahl der gerade aktiven Threads ab.
GetMaxThreads(Int32, Int32)	Ruft die Anzahl der Anforderungen für den Threadpool ab, die gleichzeitig aktiv sein können. Alle über diese Zahl hinausgehenden Anforderungen bleiben in der Warteschlange, bis die Threads des Threadpools verfügbar sind.
GetMinThreads(Int32, Int32)	Ruft die Mindestanzahl von Threads ab, die der Threadpool bei Bedarf erstellt, wenn neue Anforderungen gestellt werden, bevor zu einem Algorithmus zum Verwalten von Threaderstellung und -löschung gewechselt wird.
QueueUserWorkItem(WaitCallback)	Fügt der Warteschlange eine auszuführende Methode hinzu. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.
QueueUserWorkItem(WaitCallback, Object)	Fügt der Warteschlange eine auszuführende Methode hinzu und gibt ein Objekt an, das die von der Methode zu verwendenden Daten enthält. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.
QueueUserWorkItem<TState>(Action<TState>, TState, Boolean)	Fügt der Warteschlange eine Methode hinzu, die von einem Action<T>-Delegat zur Ausführung angegeben wird, und stellt die von der Methode zu verwendenden Daten bereit. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.
RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)	Registriert einen Delegaten, der auf eine WaitHandle-Klasse wartet, wobei für das Timeout in Millisekunden eine 32-Bit-Ganzzahl mit Vorzeichen angegeben wird.
RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)	Registriert einen Delegaten, der auf eine WaitHandle-Klasse wartet, wobei für das Timeout in Millisekunden eine 64-Bit-Ganzzahl mit Vorzeichen angegeben wird.
RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean)	Registriert einen Delegaten, der auf ein WaitHandle wartet, und gibt einen TimeSpan-Wert für das Timeout an.
RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean)	Registriert einen Delegaten, der auf eine WaitHandle-Klasse wartet, wobei für das Timeout in Millisekunden eine 32-Bit-Ganzzahl ohne Vorzeichen angegeben wird.
SetMaxThreads(Int32, Int32)	Legt die Anzahl der Anforderungen für den Threadpool fest, die gleichzeitig aktiv sein können. Alle über diese Zahl hinausgehenden Anforderungen bleiben in der Warteschlange, bis die Threads des Threadpools verfügbar sind.
SetMinThreads(Int32, Int32)	Legt die Mindestanzahl von Threads fest, die der Threadpool bei Bedarf erstellt, wenn neue Anforderungen gestellt werden, bevor zu einem Algorithmus zum Verwalten von Threaderstellung und -löschung gewechselt wird.
UnsafeQueueNativeOverlapped(NativeOverlapped*)	Stellt einen überlappenden E/A-Vorgang zur Ausführung in die Warteschlange.
UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean)	Fügt das angegebene Arbeitselementobjekt in die Warteschlange des Threadpools ein.
UnsafeQueueUserWorkItem(WaitCallback, Object)	Stellt den angegebenen Delegaten in eine Warteschlange für den Threadpool, leitet die Aufrufliste jedoch nicht an den Arbeitsthread weiter.
UnsafeQueueUserWorkItem<TState>(Action<TState>, TState, Boolean)	Fügt der Warteschlange eine Methode hinzu, die von einem Action<T>-Delegat zur Ausführung angegeben wurde, und gibt ein Objekt an, das die von der Methode zu verwendenden Daten enthält. Die Methode wird ausgeführt, wenn ein Thread des Threadpools verfügbar wird.
UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)	Registriert einen Delegaten, der auf eine WaitHandle-Klasse wartet, wobei für das Timeout in Millisekunden eine 32-Bit-Ganzzahl mit Vorzeichen verwendet wird. Diese Methode leitet den aufrufenden Stapel nicht an den Arbeitsthread weiter.
UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)	Registriert einen Delegaten, der auf eine WaitHandle-Klasse wartet, wobei für das Timeout in Millisekunden eine 64-Bit-Ganzzahl mit Vorzeichen angegeben wird. Diese Methode leitet den aufrufenden Stapel nicht an den Arbeitsthread weiter.
UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean)	Registriert einen Delegaten, der auf ein WaitHandle wartet, und gibt einen TimeSpan-Wert für das Timeout an. Diese Methode leitet den aufrufenden Stapel nicht an den Arbeitsthread weiter.
UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean)	Registriert einen Delegaten, der auf eine WaitHandle-Klasse wartet, wobei für das Timeout in Millisekunden eine 32-Bit-Ganzzahl ohne Vorzeichen angegeben wird. Diese Methode leitet den aufrufenden Stapel nicht an den Arbeitsthread weiter.

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• Threads and Threading (Threads und Threading)
• Der verwaltete Threadpooling