ThreadPool ThreadPool ThreadPool ThreadPool Class

Definición

Proporciona un grupo de subprocesos que pueden usarse para ejecutar tareas, exponer elementos de trabajo, procesar la E/S asincrónica, esperar en nombre de otros subprocesos y procesar temporizadores.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
Herencia
ThreadPoolThreadPoolThreadPoolThreadPool

Ejemplos

En el ejemplo siguiente, el subproceso principal de la aplicación pone en cola un método denominado ThreadProc para ejecutar en un subproceso ThreadPool, se suspende durante un segundo y, a continuación, sale.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. El ThreadProc método simplemente muestra un mensaje.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.

Si el comentario de la llamada a la Thread.Sleep método, el subproceso principal finaliza antes de método se ejecuta en el subproceso del grupo.If you comment out the call to the Thread.Sleep method, the main thread exits before method runs on the thread pool thread. El grupo de subprocesos usa subprocesos en segundo plano, que no mantienen la aplicación en ejecución si han finalizado todos los subprocesos de primer plano.The thread pool uses background threads, which do not keep the application running if all foreground threads have terminated. (Esto es un ejemplo sencillo de una condición de carrera).(This is a simple example of a race condition.)

Comentarios

Muchas aplicaciones crean subprocesos que pasan mucho tiempo en estado inactivo, esperando a que se produzca un evento.Many applications create threads that spend a great deal of time in the sleeping state, waiting for an event to occur. Otros subprocesos pueden entrar en estado de inactividad y activarse periódicamente para sondear en busca de un cambio o actualizar la información de estado.Other threads might enter a sleeping state only to be awakened periodically to poll for a change or update status information. El grupo de subprocesos permite usar subprocesos más eficaz, ya que proporciona la aplicación con un grupo de subprocesos de trabajo que están administrados por el sistema.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. Ejemplos de operaciones que usan los subprocesos de grupo incluyen lo siguiente:Examples of operations that use thread pool threads include the following:

  • Cuando creas un Task o Task<TResult> objeto para realizar alguna tarea de forma asincrónica, de forma predeterminada, la tarea está programada para ejecutarse en un subproceso ThreadPool.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.

  • Los temporizadores asincrónicos usar el grupo de subprocesos.Asynchronous timers use the thread pool. Subprocesos de grupo ejecutarán devoluciones de llamada de la System.Threading.Timer clase y provocar eventos desde el System.Timers.Timer clase.Thread pool threads execute callbacks from the System.Threading.Timer class and raise events from the System.Timers.Timer class.

  • Al usar identificadores de espera registrada, un subproceso del sistema supervisa el estado de los identificadores de espera.When you use registered wait handles, a system thread monitors the status of the wait handles. Cuando se completa una operación de espera, un subproceso del grupo de subprocesos de trabajo ejecuta la función de devolución de llamada correspondiente.When a wait operation completes, a worker thread from the thread pool executes the corresponding callback function.

  • Cuando se llama a la QueueUserWorkItem método para poner en cola un método para su ejecución en un subproceso ThreadPool.When you call the QueueUserWorkItem method to queue a method for execution on a thread pool thread. Para ello, pasando al método un WaitCallback delegar.You do this by passing the method a WaitCallback delegate. El delegado tiene la firmaThe delegate has the signature

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

    donde state es un objeto que contiene datos para su uso por el delegado.where state is an object that contains data to be used by the delegate. Los datos reales se pueden pasar al delegado mediante una llamada a la QueueUserWorkItem(WaitCallback, Object) método.The actual data can be passed to the delegate by calling the QueueUserWorkItem(WaitCallback, Object) method.

Nota

Los subprocesos en el grupo de subprocesos administrados son subprocesos en segundo plano.The threads in the managed thread pool are background threads. Es decir, sus IsBackground propiedades son true.That is, their IsBackground properties are true. Esto significa que un ThreadPool subproceso no mantendrá una aplicación que se ejecuta después de que han salido de todos los subprocesos de primer plano.This means that a ThreadPool thread will not keep an application running after all foreground threads have exited.

Importante

Cuando el grupo de subprocesos reutiliza un subproceso, no elimina los datos de almacenamiento local de subprocesos o en los campos que se marcan con el ThreadStaticAttribute atributo.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. Por lo tanto, cuando un método examina el almacenamiento local de subprocesos o campos que se marcan con el ThreadStaticAttribute atributo, los valores que encuentra podrían quedar a través de un uso anterior de subproceso de grupo.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.

También puede poner en cola los elementos de trabajo que no están relacionadas con una operación de espera para el grupo de subprocesos.You can also queue work items that are not related to a wait operation to the thread pool. Para solicitar que un subproceso en el grupo de subprocesos controle un elemento de trabajo, llame a la QueueUserWorkItem método.To request that a work item be handled by a thread in the thread pool, call the QueueUserWorkItem method. Este método toma como parámetro una referencia al método o delegado que llamará el subproceso seleccionado del grupo de subprocesos.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. No hay ninguna manera de cancelar un elemento de trabajo después de que se ha puesto en cola.There is no way to cancel a work item after it has been queued.

Los temporizadores de la cola del temporizador y operaciones de espera registradas también utilizan el grupo de subprocesos.Timer-queue timers and registered wait operations also use the thread pool. Sus funciones de devolución de llamada se ponen en cola para el grupo de subprocesos.Their callback functions are queued to the thread pool.

Hay un grupo de subprocesos por proceso.There is one thread pool per process. A partir de .NET Framework 4.NET Framework 4, el tamaño predeterminado del grupo de subprocesos de un proceso depende de varios factores, como el tamaño del espacio de direcciones virtuales.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. Un proceso puede llamar al método GetMaxThreads para determinar el número de subprocesos.A process can call the GetMaxThreads method to determine the number of threads. Se puede cambiar el número de subprocesos en el grupo de subprocesos mediante el uso de la SetMaxThreads método.The number of threads in the thread pool can be changed by using the SetMaxThreads method. Cada subproceso utiliza el tamaño de pila predeterminado y se ejecuta con la prioridad predeterminada.Each thread uses the default stack size and runs at the default priority.

Nota

Código no administrado que hospeda .NET Framework puede cambiar el tamaño del grupo de subprocesos mediante la CorSetMaxThreads función definida en el archivo 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.

El grupo de subprocesos proporciona nuevos subprocesos de trabajo o subprocesos de finalización de E/S a petición hasta que alcanza el valor mínimo para cada categoría.The thread pool provides new worker threads or I/O completion threads on demand until it reaches the minimum for each category. Cuando se alcanza el mínimo, el grupo de subprocesos puede crear subprocesos adicionales en esa categoría o espere hasta que se completen algunas tareas.When a minimum is reached, the thread pool can create additional threads in that category or wait until some tasks complete. A partir de .NET Framework 4.NET Framework 4, el grupo de subprocesos crea y destruye subprocesos de trabajo para optimizar el rendimiento, definido como el número de tareas que se completan por unidad de tiempo.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. Si hay demasiados pocos subprocesos, puede que los recursos disponibles no se usen de manera óptima, mientras que si hay demasiados subprocesos, puede aumentar la contención de recursos.Too few threads might not make optimal use of available resources, whereas too many threads could increase resource contention.

Nota

Cuando la demanda es baja, el número real de subprocesos del grupo de subprocesos puede descender por debajo de los valores mínimos.When demand is low, the actual number of thread pool threads can fall below the minimum values.

Puede utilizar el método GetMinThreads para obtener estos valores mínimos.You can use the GetMinThreads method to obtain these minimum values.

Precaución

Puede usar el SetMinThreads método para aumentar el número mínimo de subprocesos.You can use the SetMinThreads method to increase the minimum number of threads. Sin embargo, aumentar innecesariamente estos valores puede causar problemas de rendimiento.However, unnecessarily increasing these values can cause performance problems. Si se inician demasiadas tareas al mismo tiempo, puede que todas ellas parezcan funcionar con lentitud.If too many tasks start at the same time, all of them might appear to be slow. En la mayoría de los casos, el grupo de subprocesos funciona mejor con su propio algoritmo de asignación de subprocesos.In most cases the thread pool will perform better with its own algorithm for allocating threads.

Métodos

BindHandle(IntPtr) BindHandle(IntPtr) BindHandle(IntPtr) BindHandle(IntPtr)

Enlaza un identificador del sistema operativo a ThreadPool.Binds an operating system handle to the ThreadPool.

BindHandle(SafeHandle) BindHandle(SafeHandle) BindHandle(SafeHandle) BindHandle(SafeHandle)

Enlaza un identificador del sistema operativo a ThreadPool.Binds an operating system handle to the ThreadPool.

GetAvailableThreads(Int32, Int32) GetAvailableThreads(Int32, Int32) GetAvailableThreads(Int32, Int32) GetAvailableThreads(Int32, Int32)

Recupera la diferencia entre el número máximo de subprocesos de grupo de subprocesos devuelto por el método GetMaxThreads(Int32, Int32) y el número activo actualmente.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) GetMaxThreads(Int32, Int32) GetMaxThreads(Int32, Int32) GetMaxThreads(Int32, Int32)

Recupera el número de solicitudes al grupo de subprocesos que pueden estar activas al mismo tiempo.Retrieves the number of requests to the thread pool that can be active concurrently. Todas las solicitudes que pasen de ese número permanecen en la cola hasta que haya disponibles subprocesos de grupo de subprocesos.All requests above that number remain queued until thread pool threads become available.

GetMinThreads(Int32, Int32) GetMinThreads(Int32, Int32) GetMinThreads(Int32, Int32) GetMinThreads(Int32, Int32)

Recupera el número mínimo de subprocesos que el grupo de subprocesos crea a petición, según se realizan nuevas solicitudes, antes de conmutar a un algoritmo para administrar la creación y destrucción de subprocesos.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) QueueUserWorkItem(WaitCallback) QueueUserWorkItem(WaitCallback) QueueUserWorkItem(WaitCallback)

Pone en cola un método para su ejecución.Queues a method for execution. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

QueueUserWorkItem(WaitCallback, Object) QueueUserWorkItem(WaitCallback, Object) QueueUserWorkItem(WaitCallback, Object) QueueUserWorkItem(WaitCallback, Object)

Pone un método en cola para su ejecución y especifica un objeto que contiene los datos que debe usar el método.Queues a method for execution, and specifies an object containing data to be used by the method. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

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

Pone un método en cola para su ejecución especificado por un delegado de Action<T> y proporciona los datos que debe usar el método.Queues a method specified by an Action<T> delegate for execution, and provides data to be used by the method. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

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

Registra un delegado para que espere a la clase WaitHandle y especifica un entero de 32 bits sin signo como tiempo de espera, en milisegundos.Registers a delegate to wait for a WaitHandle, specifying a 32-bit unsigned integer for the time-out in milliseconds.

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

Registra un delegado para que espere a la clase WaitHandle y especifica un valor TimeSpan como tiempo de espera.Registers a delegate to wait for a WaitHandle, specifying a TimeSpan value for the time-out.

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

Registra un delegado para que espere a la clase WaitHandle y especifica un entero de 32 bits con signo como tiempo de espera, en milisegundos.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) RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean) RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean) RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)

Registra un delegado para que espere a la clase WaitHandle y especifica un entero de 64 bits con signo como tiempo de espera, en milisegundos.Registers a delegate to wait for a WaitHandle, specifying a 64-bit signed integer for the time-out in milliseconds.

SetMaxThreads(Int32, Int32) SetMaxThreads(Int32, Int32) SetMaxThreads(Int32, Int32) SetMaxThreads(Int32, Int32)

Establece el número de solicitudes al grupo de subprocesos que pueden estar activas al mismo tiempo.Sets the number of requests to the thread pool that can be active concurrently. Todas las solicitudes que pasen de ese número permanecen en la cola hasta que haya disponibles subprocesos de grupo de subprocesos.All requests above that number remain queued until thread pool threads become available.

SetMinThreads(Int32, Int32) SetMinThreads(Int32, Int32) SetMinThreads(Int32, Int32) SetMinThreads(Int32, Int32)

Establece el número mínimo de subprocesos que el grupo de subprocesos crea a petición, según se realizan nuevas solicitudes, antes de conmutar a un algoritmo para administrar la creación y destrucción de subprocesos.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*) UnsafeQueueNativeOverlapped(NativeOverlapped*) UnsafeQueueNativeOverlapped(NativeOverlapped*) UnsafeQueueNativeOverlapped(NativeOverlapped*)

Pone en cola una operación de E/S superpuesta para que se ejecute.Queues an overlapped I/O operation for execution.

UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean) UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean) UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean) UnsafeQueueUserWorkItem(IThreadPoolWorkItem, Boolean)
UnsafeQueueUserWorkItem(WaitCallback, Object) UnsafeQueueUserWorkItem(WaitCallback, Object) UnsafeQueueUserWorkItem(WaitCallback, Object) UnsafeQueueUserWorkItem(WaitCallback, Object)

Pone en cola el delegado especificado en el grupo de subprocesos, pero no propaga la pila de llamadas al subproceso de trabajo.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) UnsafeQueueUserWorkItem<TState>(Action<TState>, TState, Boolean) UnsafeQueueUserWorkItem<TState>(Action<TState>, TState, Boolean) UnsafeQueueUserWorkItem<TState>(Action<TState>, TState, Boolean)

Pone un método en cola para su ejecución especificado por un delegado de Action<T> y especifica un objeto que contiene los datos que debe usar el método.Queues a method specified by an Action<T> delegate for execution, and specifies an object containing data to be used by the method. El método se ejecuta cuando hay disponible un subproceso de grupo de subprocesos.The method executes when a thread pool thread becomes available.

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

Registra un delegado para que espere a la clase WaitHandle y especifica un valor TimeSpan como tiempo de espera. Este método no propaga la pila de llamadas al subproceso de trabajo.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, Int32, Boolean) UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean) UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean) UnsafeRegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)

Registra un delegado para que espere a la clase WaitHandle y usa un entero de 32 bits con signo como tiempo de espera, en milisegundos.Registers a delegate to wait for a WaitHandle, using a 32-bit signed integer for the time-out in milliseconds. Este método no propaga la pila de llamadas al subproceso de trabajo.This method does not propagate the calling stack to the worker thread.

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

Registra un delegado para que espere a la clase WaitHandle y especifica un entero de 64 bits con signo como tiempo de espera, en milisegundos.Registers a delegate to wait for a WaitHandle, specifying a 64-bit signed integer for the time-out in milliseconds. Este método no propaga la pila de llamadas al subproceso de trabajo.This method does not propagate the calling stack to the worker thread.

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

Registra un delegado para que espere a la clase WaitHandle y especifica un entero de 32 bits sin signo como tiempo de espera, en milisegundos.Registers a delegate to wait for a WaitHandle, specifying a 32-bit unsigned integer for the time-out in milliseconds. Este método no propaga la pila de llamadas al subproceso de trabajo.This method does not propagate the calling stack to the worker thread.

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.This type is thread safe.

Consulte también: