ThreadPool Clase

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
ThreadPool

Ejemplos

En el ejemplo siguiente, el subproceso de aplicación principal pone en cola un método denominado ThreadProc para ejecutarse en un subproceso de grupo de subprocesos, se suspende durante un segundo y, a continuación, se cierra.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 método ThreadProc 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 se marca como comentario la llamada al método Thread.Sleep, el subproceso principal sale antes de que el método se ejecute en el subproceso del grupo de subprocesos.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 todos los subprocesos de primer plano han terminado.The thread pool uses background threads, which do not keep the application running if all foreground threads have terminated. (Este 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 invierten mucho tiempo en el estado inactivo, a la espera de 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 un estado de inactividad que solo se activa periódicamente para sondear un cambio o información de estado de actualización.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 de forma más eficaz al proporcionar a la aplicación un grupo de subprocesos de trabajo 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. Entre los ejemplos de operaciones que usan subprocesos de grupo de subprocesos se incluyen los siguientes:Examples of operations that use thread pool threads include the following:

  • Cuando se crea un objeto Task o Task<TResult> para realizar alguna tarea de forma asincrónica, de forma predeterminada la tarea está programada para ejecutarse en un subproceso del grupo de subprocesos.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 usan el grupo de subprocesos.Asynchronous timers use the thread pool. Los subprocesos del grupo de subprocesos ejecutan devoluciones de llamada de la clase System.Threading.Timer y generan eventos de la clase System.Timers.Timer.Thread pool threads execute callbacks from the System.Threading.Timer class and raise events from the System.Timers.Timer class.

  • Cuando se usan identificadores de espera registrados, 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 de trabajo del grupo de subprocesos 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.

  • Al llamar al método QueueUserWorkItem para poner en cola un método para su ejecución en un subproceso del grupo de subprocesos.When you call the QueueUserWorkItem method to queue a method for execution on a thread pool thread. Para ello, pase el método a un delegado WaitCallback.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 los datos que el delegado va a utilizar.where state is an object that contains data to be used by the delegate. Los datos reales se pueden pasar al delegado llamando al método QueueUserWorkItem(WaitCallback, Object).The actual data can be passed to the delegate by calling the QueueUserWorkItem(WaitCallback, Object) method.

Nota

Los subprocesos del grupo de subprocesos administrados son subprocesos en segundo plano.The threads in the managed thread pool are background threads. Es decir, las propiedades IsBackground son true.That is, their IsBackground properties are true. Esto significa que un subproceso ThreadPool no mantendrá una aplicación en ejecución una vez finalizados todos los subprocesos en 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 vuelve a utilizar un subproceso, no borra los datos en el almacenamiento local de subprocesos ni en los campos marcados con el atributo 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. Por lo tanto, cuando un método examina el almacenamiento local de subprocesos o los campos marcados con el atributo ThreadStaticAttribute, es posible que los valores que encuentre se hayan dejado de un uso anterior del subproceso del grupo de subprocesos.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 relacionados con una operación de espera en 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 del grupo de subprocesos controle un elemento de trabajo, llame al método QueueUserWorkItem.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 al que llamará el subproceso seleccionado en el 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 una vez que se ha puesto en la cola.There is no way to cancel a work item after it has been queued.

Temporizador: los temporizadores de cola y las operaciones de espera registradas también usan 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 en el grupo de subprocesos.Their callback functions are queued to the thread pool.

Hay un grupo de subprocesos por cada 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. El número de subprocesos del grupo de subprocesos se puede cambiar mediante el método SetMaxThreads.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

El código no administrado que hospeda el .NET Framework puede cambiar el tamaño del grupo de subprocesos mediante la función CorSetMaxThreads, que se define 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 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 un mínimo, el grupo de subprocesos puede crear subprocesos adicionales en esa categoría o esperar a 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 método SetMinThreads 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.

Propiedades

CompletedWorkItemCount

Obtiene el número de elementos de trabajo que se han procesado hasta ahora.Gets the number of work items that have been processed so far.

PendingWorkItemCount

Obtiene el número de elementos de trabajo que se encuentran actualmente en cola para procesarse.Gets the number of work items that are currently queued to be processed.

ThreadCount

Obtiene el número de subprocesos del grupo de subprocesos que existen actualmente.Gets the number of thread pool threads that currently exist.

Métodos

BindHandle(IntPtr)

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

BindHandle(SafeHandle)

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

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)

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)

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)

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)

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)

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, 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)

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.

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, 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.

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)

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*)

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)

Pone en cola el objeto del elemento de trabajo especificado en el grupo de subprocesos.Queues the specified work item object to the thread pool.

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)

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, 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)

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, 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, 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: