ThreadPool Clase

Definición

public ref class ThreadPool abstract sealed

public ref class ThreadPool sealed

public static class ThreadPool

public sealed class ThreadPool

type ThreadPool = class

Public Class ThreadPool

Public NotInheritable Class ThreadPool

Herencia

Object

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 del grupo de subprocesos, se suspende durante un segundo y, a continuación, se cierra. El ThreadProc método simplemente muestra un mensaje.

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 comenta la llamada al Thread.Sleep método , el subproceso principal sale antes de que el método se ejecute en el subproceso del grupo de subprocesos. El grupo de subprocesos usa subprocesos en segundo plano, que no mantienen la aplicación en ejecución si todos los subprocesos en primer plano han finalizado. (Este es un ejemplo sencillo de una condición de carrera).

Comentarios

Muchas aplicaciones crean subprocesos que pasan mucho tiempo en estado de suspensión, esperando a que se produzca un evento. Otros subprocesos pueden entrar en un estado de suspensión solo para despertarse periódicamente para sondear una información de estado de cambio o actualización. El grupo de subprocesos permite usar subprocesos de forma más eficaz proporcionando a la aplicación un grupo de subprocesos de trabajo administrados por el sistema. Entre los ejemplos de operaciones que usan subprocesos del grupo de subprocesos se incluyen los siguientes:

• Cuando se crea un Task objeto 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.

• Los temporizadores asincrónicos usan el grupo de subprocesos. Los subprocesos del grupo de subprocesos ejecutan devoluciones de llamada desde la System.Threading.Timer clase y generan eventos de la System.Timers.Timer clase .

• Cuando se usan identificadores de espera registrados, un subproceso del sistema supervisa el estado de los identificadores de espera. 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.

• Cuando se llama al QueueUserWorkItem método para poner en cola un método para su ejecución en un subproceso de grupo de subprocesos. Para ello, pase el método un WaitCallback delegado. El delegado tiene la firma

  void WaitCallback(Object state)  
  

  Sub WaitCallback(state As Object)  
  

  donde state es un objeto que contiene los datos que va a usar el delegado. Los datos reales se pueden pasar al delegado llamando al QueueUserWorkItem(WaitCallback, Object) método .

También puede poner en cola los elementos de trabajo que no están relacionados con una operación de espera al grupo de subprocesos. Para solicitar que un subproceso del grupo de subprocesos controle un elemento de trabajo, llame al QueueUserWorkItem método . 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. No hay ninguna manera de cancelar un elemento de trabajo después de que se haya puesto en cola.

Los temporizadores de cola de temporizador y las operaciones de espera registradas también usan el grupo de subprocesos. Sus funciones de devolución de llamada se ponen en cola en el grupo de subprocesos.

Hay un grupo de subprocesos por proceso. A partir de .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. Un proceso puede llamar al método GetMaxThreads para determinar el número de subprocesos. El número de subprocesos del grupo de subprocesos se puede cambiar mediante el SetMaxThreads método . Cada subproceso usa el tamaño de pila predeterminado y se ejecuta con la prioridad predeterminada.

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áximo para cada categoría. Cuando se alcanza un máximo, el grupo de subprocesos puede crear subprocesos adicionales en esa categoría o esperar hasta que se completen algunas tareas. A partir de .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. 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.

Puede utilizar el método GetMinThreads para obtener estos valores mínimos.

Propiedades

Métodos

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.

Consulte también

• Subprocesos y subprocesamiento
• Agrupación de subprocesos administrados