ThreadPool Třída

Definice

Poskytuje fond vláken, která lze použít k provádění úloh, odesílání pracovních položek, zpracování asynchronních vstupně-výstupních operací, čekání jménem jiných vláken a procesu časovače.Provides a pool of threads that can be used to execute tasks, post work items, process asynchronous I/O, wait on behalf of other threads, and process timers.

public ref class ThreadPool abstract sealed
public static class ThreadPool
type ThreadPool = class
Public Class ThreadPool
Dědičnost
ThreadPool

Příklady

V následujícím příkladu hlavní vlákno aplikace zařadí metodu nazvanou ThreadProc pro spuštění ve fondu vláken, přejde do režimu spánku pro jednu sekundu a pak ukončí.In the following example, the main application thread queues a method named ThreadProc to execute on a thread pool thread, sleeps for one second, and then exits. Metoda ThreadProc jednoduše zobrazí zprávu.The ThreadProc method simply displays a message.

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.

Pokud zadáte komentář k volání metody Thread.Sleep, hlavní vlákno se ukončí před spuštěním metody ve vlákně fondu vláken.If you comment out the call to the Thread.Sleep method, the main thread exits before method runs on the thread pool thread. Fond vláken používá vlákna na pozadí, které neudržují aplikaci spuštěnou, pokud byla ukončena všechna vlákna na popředí.The thread pool uses background threads, which do not keep the application running if all foreground threads have terminated. (Jedná se o jednoduchý příklad sporu.)(This is a simple example of a race condition.)

Poznámky

Mnoho aplikací vytváří vlákna, která tráví velkou dobu provozu ve stavu spánku a čeká na výskyt události.Many applications create threads that spend a great deal of time in the sleeping state, waiting for an event to occur. Další vlákna můžou přejít do režimu spánku jenom v případě, že se budou pravidelně probuzeny dotazovat na informace o změně nebo stavu aktualizace.Other threads might enter a sleeping state only to be awakened periodically to poll for a change or update status information. Fond vláken vám umožňuje efektivněji používat vlákna tím, že poskytuje aplikaci s fondem pracovních vláken, která jsou spravovaná systémem.The thread pool enables you to use threads more efficiently by providing your application with a pool of worker threads that are managed by the system. Příklady operací, které používají vlákna fondu vláken, zahrnují následující:Examples of operations that use thread pool threads include the following:

  • Když vytvoříte objekt Task nebo Task<TResult> k provedení některé úlohy asynchronně, ve výchozím nastavení je naplánováno spuštění úlohy ve vlákně fondu vláken.When you create a Task or Task<TResult> object to perform some task asynchronously, by default the task is scheduled to run on a thread pool thread.

  • Asynchronní časovače používají fond vláken.Asynchronous timers use the thread pool. Vlákna fondu vláken spouštějí zpětná volání z třídy System.Threading.Timer a vyvolávají události z System.Timers.Timer třídy.Thread pool threads execute callbacks from the System.Threading.Timer class and raise events from the System.Timers.Timer class.

  • Když použijete registrované obslužné rutiny čekání, systémové vlákno monitoruje stav obslužných rutin čekání.When you use registered wait handles, a system thread monitors the status of the wait handles. Po dokončení operace čekání provede pracovní podproces z fondu vláken odpovídající funkci zpětného volání.When a wait operation completes, a worker thread from the thread pool executes the corresponding callback function.

  • Při volání metody QueueUserWorkItem pro zařazení metody ke spuštění ve vlákně fondu vláken.When you call the QueueUserWorkItem method to queue a method for execution on a thread pool thread. Provedete to tak, že předáte metodu WaitCallback delegát.You do this by passing the method a WaitCallback delegate. Delegát má podpis.The delegate has the signature

    void WaitCallback(Object state)  
    
    Sub WaitCallback(state As Object)  
    

    kde state je objekt, který obsahuje data, která má použít delegát.where state is an object that contains data to be used by the delegate. Vlastní data lze předat delegátovi voláním metody QueueUserWorkItem(WaitCallback, Object).The actual data can be passed to the delegate by calling the QueueUserWorkItem(WaitCallback, Object) method.

Poznámka

Vlákna ve fondu spravovaných vláken jsou vlákna na pozadí.The threads in the managed thread pool are background threads. To znamená, že jejich vlastnosti IsBackground jsou true.That is, their IsBackground properties are true. To znamená, že vlákno ThreadPool nezachová aplikaci spuštěnou po ukončení všech vláken na popředí.This means that a ThreadPool thread will not keep an application running after all foreground threads have exited.

Důležité

Když fond vláken znovu používá vlákno, nevymaže data v thread local úložiště nebo v polích, která jsou označena atributem ThreadStaticAttribute.When the thread pool reuses a thread, it does not clear the data in thread local storage or in fields that are marked with the ThreadStaticAttribute attribute. Proto když metoda prověřuje thread local úložiště nebo pole, která jsou označena atributem ThreadStaticAttribute, hledané hodnoty mohou být ponechány ze staršího použití vlákna fondu vláken.Therefore, when a method examines thread local storage or fields that are marked with the ThreadStaticAttribute attribute, the values it finds might be left over from an earlier use of the thread pool thread.

Můžete také zařadit do fronty pracovní položky, které nesouvisí s operací čekání do fondu vláken.You can also queue work items that are not related to a wait operation to the thread pool. Chcete-li požádat, aby byla pracovní položka zpracována vláknem ve fondu vláken, zavolejte metodu QueueUserWorkItem.To request that a work item be handled by a thread in the thread pool, call the QueueUserWorkItem method. Tato metoda přebírá jako parametr odkaz na metodu nebo delegáta, které bude voláno vláknem vybraným z fondu vláken.This method takes as a parameter a reference to the method or delegate that will be called by the thread selected from the thread pool. Neexistuje žádný způsob, jak zrušit pracovní položku poté, co byla zařazena do fronty.There is no way to cancel a work item after it has been queued.

Časovač – časovače front a registrované čekací operace také používají fond vláken.Timer-queue timers and registered wait operations also use the thread pool. Jejich funkce zpětného volání jsou zařazeny do fondu vláken.Their callback functions are queued to the thread pool.

Každý proces má jeden fond vláken.There is one thread pool per process. Počínaje .NET Framework 4.NET Framework 4, výchozí velikost fondu vláken pro proces závisí na několika faktorech, například na velikosti virtuálního adresního prostoru.Beginning with the .NET Framework 4.NET Framework 4, the default size of the thread pool for a process depends on several factors, such as the size of the virtual address space. Proces může volat metodu GetMaxThreads k určení počtu vláken.A process can call the GetMaxThreads method to determine the number of threads. Počet vláken ve fondu vláken lze změnit pomocí metody SetMaxThreads.The number of threads in the thread pool can be changed by using the SetMaxThreads method. Každé vlákno používá výchozí velikost zásobníku a spouští se s výchozí prioritou.Each thread uses the default stack size and runs at the default priority.

Poznámka

Nespravovaný kód, který je hostitelem .NET Framework, může změnit velikost fondu vláken pomocí funkce CorSetMaxThreads, která je definována v souboru Mscoree. h.Unmanaged code that hosts the .NET Framework can change the size of the thread pool by using the CorSetMaxThreads function, defined in the mscoree.h file.

Fond vláken poskytuje nová pracovní vlákna nebo vstupně-výstupní vlákna na vyžádání, dokud nedosáhne minima pro každou kategorii.The thread pool provides new worker threads or I/O completion threads on demand until it reaches the minimum for each category. Po dosažení minima může fond vláken vytvořit další vlákna v této kategorii nebo počkat na dokončení některých úloh.When a minimum is reached, the thread pool can create additional threads in that category or wait until some tasks complete. Počínaje .NET Framework 4.NET Framework 4 fond vláken vytvoří a zničí pracovní vlákna, aby bylo možné optimalizovat propustnost, která je definována jako počet úloh, které jsou dokončeny na jednotku času.Beginning with the .NET Framework 4.NET Framework 4, the thread pool creates and destroys worker threads in order to optimize throughput, which is defined as the number of tasks that complete per unit of time. Příliš málo vláken nemusí mít optimální využití dostupných prostředků, zatímco příliš mnoho vláken může zvýšit spory prostředků.Too few threads might not make optimal use of available resources, whereas too many threads could increase resource contention.

Poznámka

Pokud je poptávka nízká, skutečný počet vláken fondu vláken může klesnout pod minimální hodnotu.When demand is low, the actual number of thread pool threads can fall below the minimum values.

K získání těchto minimálních hodnot můžete použít metodu GetMinThreads.You can use the GetMinThreads method to obtain these minimum values.

Upozornění

K navýšení minimálního počtu vláken můžete použít metodu SetMinThreads.You can use the SetMinThreads method to increase the minimum number of threads. Nicméně zbytečně rostoucí tyto hodnoty mohou způsobit problémy s výkonem.However, unnecessarily increasing these values can cause performance problems. Pokud je spuštěno příliš mnoho úloh současně, je možné, že jsou všechny pravděpodobně pomalé.If too many tasks start at the same time, all of them might appear to be slow. Ve většině případů bude fond vláken lépe fungovat s vlastním algoritmem pro přidělování vláken.In most cases the thread pool will perform better with its own algorithm for allocating threads.

Vlastnosti

CompletedWorkItemCount

Získá počet pracovních položek, které byly doposud zpracovány.Gets the number of work items that have been processed so far.

PendingWorkItemCount

Získá počet pracovních položek, které jsou aktuálně zařazeny do fronty ke zpracování.Gets the number of work items that are currently queued to be processed.

ThreadCount

Získá počet vláken fondu vláken, které aktuálně existují.Gets the number of thread pool threads that currently exist.

Metody

BindHandle(IntPtr)

Váže popisovač operačního systému na ThreadPool.Binds an operating system handle to the ThreadPool.

BindHandle(SafeHandle)

Váže popisovač operačního systému na ThreadPool.Binds an operating system handle to the ThreadPool.

GetAvailableThreads(Int32, Int32)

Načte rozdíl mezi maximálním počtem vláken fondu vláken vráceného metodou GetMaxThreads(Int32, Int32) a aktuálně aktivním číslem.Retrieves the difference between the maximum number of thread pool threads returned by the GetMaxThreads(Int32, Int32) method, and the number currently active.

GetMaxThreads(Int32, Int32)

Načte počet žádostí do fondu vláken, které mohou být souběžně aktivní.Retrieves the number of requests to the thread pool that can be active concurrently. Všechny žádosti nad tímto číslem zůstanou zařazené do fronty, dokud nebudou k dispozici vlákna fondu vláken.All requests above that number remain queued until thread pool threads become available.

GetMinThreads(Int32, Int32)

Načte minimální počet vláken, které fond vláken vytvoří na vyžádání, protože se vytvoří nové požadavky, než se přepne na algoritmus pro správu vytvoření a zničení vlákna.Retrieves the minimum number of threads the thread pool creates on demand, as new requests are made, before switching to an algorithm for managing thread creation and destruction.

QueueUserWorkItem(WaitCallback)

Zařadí do fronty metodu pro provedení.Queues a method for execution. Metoda se spustí, když bude k dispozici vlákno fondu vláken.The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback, Object)

Zařadí do fronty metodu pro provedení a určí objekt obsahující data, která má metoda použít.Queues a method for execution, and specifies an object containing data to be used by the method. Metoda se spustí, když bude k dispozici vlákno fondu vláken.The method executes when a thread pool thread becomes available.

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

Zařadí metodu určenou delegátem Action<T> a poskytuje data, která mají být použita metodou.Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. Metoda se spustí, když bude k dispozici vlákno fondu vláken.The method executes when a thread pool thread becomes available.

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)

Zaregistruje delegáta pro čekání na WaitHandle, přičemž pro časový limit v milisekundách se zadává 32 celé číslo se znaménkem.Registers a delegate to wait for a WaitHandle, specifying a 32-bit signed integer for the time-out in milliseconds.

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)

Zaregistruje delegáta pro čekání na WaitHandle, přičemž pro časový limit v milisekundách se zadává 64 celé číslo se znaménkem.Registers a delegate to wait for a WaitHandle, specifying a 64-bit signed integer for the time-out in milliseconds.

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean)

Zaregistruje delegáta pro čekání na WaitHandle, přičemž určí TimeSpan hodnotu časového limitu.Registers a delegate to wait for a WaitHandle, specifying a TimeSpan value for the time-out.

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean)

Zaregistruje delegáta pro čekání na WaitHandle, přičemž pro časový limit v milisekundách se zadává 32 unsigned integer.Registers a delegate to wait for a WaitHandle, specifying a 32-bit unsigned integer for the time-out in milliseconds.

SetMaxThreads(Int32, Int32)

Nastaví počet požadavků na fond vláken, které mohou být souběžně aktivní.Sets the number of requests to the thread pool that can be active concurrently. Všechny žádosti nad tímto číslem zůstanou zařazené do fronty, dokud nebudou k dispozici vlákna fondu vláken.All requests above that number remain queued until thread pool threads become available.

SetMinThreads(Int32, Int32)

Nastaví minimální počet vláken, které fond vláken vytvoří na vyžádání, protože se vytvoří nové požadavky, než se přepne na algoritmus pro správu vytvoření a zničení vlákna.Sets the minimum number of threads the thread pool creates on demand, as new requests are made, before switching to an algorithm for managing thread creation and destruction.

UnsafeQueueNativeOverlapped(NativeOverlapped*)

Zařadí Překrývající vstupně-výstupní operace pro provádění.Queues an overlapped I/O operation for execution.

UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean)

Zařadí zadaný objekt pracovní položky do fondu vláken.Queues the specified work item object to the thread pool.

UnsafeQueueUserWorkItem(WaitCallback, Object)

Zařadí zadaného delegáta do fondu vláken, ale nešíří volající zásobník do pracovního vlákna.Queues the specified delegate to the thread pool, but does not propagate the calling stack to the worker thread.

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

Zařadí metodu určenou delegátem Action<T> pro spuštění a určí objekt obsahující data, která má metoda použít.Queues a method specified by an Action<T> delegate for execution, and specifies an object containing data to be used by the method. Metoda se spustí, když bude k dispozici vlákno fondu vláken.The method executes when a thread pool thread becomes available.

UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)

Zaregistruje delegáta pro čekání na WaitHandle s použitím 32ého celého čísla se znaménkem pro časový limit v milisekundách.Registers a delegate to wait for a WaitHandle, using a 32-bit signed integer for the time-out in milliseconds. Tato metoda nešíří volající zásobník do pracovního vlákna.This method does not propagate the calling stack to the worker thread.

UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)

Zaregistruje delegáta pro čekání na WaitHandle, přičemž pro časový limit v milisekundách se zadává 64 celé číslo se znaménkem.Registers a delegate to wait for a WaitHandle, specifying a 64-bit signed integer for the time-out in milliseconds. Tato metoda nešíří volající zásobník do pracovního vlákna.This method does not propagate the calling stack to the worker thread.

UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean)

Zaregistruje delegáta pro čekání na WaitHandle, přičemž určí TimeSpan hodnotu časového limitu. Tato metoda nešíří volající zásobník do pracovního vlákna.Registers a delegate to wait for a WaitHandle, specifying a TimeSpan value for the time-out. This method does not propagate the calling stack to the worker thread.

UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean)

Zaregistruje delegáta pro čekání na WaitHandle, přičemž pro časový limit v milisekundách se zadává 32 unsigned integer.Registers a delegate to wait for a WaitHandle, specifying a 32-bit unsigned integer for the time-out in milliseconds. Tato metoda nešíří volající zásobník do pracovního vlákna.This method does not propagate the calling stack to the worker thread.

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.This type is thread safe.

Viz také