Exportar (0) Imprimir
Expandir todo

ThreadPool (Clase)

Proporciona un grupo de subprocesos que pueden utilizarse para exponer elementos de trabajo, procesar la E/S asincrónica, esperar en nombre de otros subprocesos y procesar temporizadores.

Espacio de nombres: System.Threading
Ensamblado: mscorlib (en mscorlib.dll)

public ref class ThreadPool abstract sealed
public final class ThreadPool
public final class ThreadPool
No aplicable.

NotaNota:

El atributo HostProtectionAttribute aplicado a esta clase tiene el valor de propiedad Resources siguiente: Synchronization | ExternalThreading. HostProtectionAttribute no afecta a las aplicaciones de escritorio (que normalmente se inician al hacer doble clic en un icono, escribir un comando o escribir una dirección URL en un explorador). Para obtener más información, vea la clase HostProtectionAttribute o Programación de SQL Server y atributos de protección del host.

Muchas aplicaciones crean subprocesos que pasan mucho tiempo en estado de inactividad, esperando a que se produzca un evento. Otros subprocesos pueden entrar en estado de inactividad y activarse periódicamente para comprobar si se ha producido algún cambio o para actualizar la información de estado. La agrupación de subprocesos permite utilizar los subprocesos de forma más eficaz, ya que suministra a la aplicación un grupo de subprocesos de trabajo administrados por el sistema. Un subproceso supervisa el estado de varias operaciones de espera que se encuentran en la cola del grupo de subprocesos. Cuando una operación de espera finaliza, un subproceso de trabajo del grupo de subprocesos ejecuta la función de devolución de llamada correspondiente.

NotaNota:

Los subprocesos del grupo de subprocesos administrados son los subprocesos de fondo. Es decir, sus propiedades IsBackground son true. Esto significa que un subproceso ThreadPool no hará que la aplicación se siga ejecutando cuando todos los subprocesos de primer plano hayan terminado.

También pueden colocarse en la cola del grupo de subprocesos elementos de trabajo no relacionados con una operación de espera. Para solicitar que un subproceso del grupo de subprocesos controle un elemento de trabajo, hay que llamar al método QueueUserWorkItem. Este método toma como parámetro una referencia al método o delegado al que llamará el subproceso seleccionado del grupo de subprocesos. No se puede cancelar un elemento de trabajo después de haberlo colocado en la cola.

Los temporizadores de la cola de temporizadores y las operaciones de espera registradas también utilizan el grupo de subprocesos. Sus funciones de devolución de llamada se colocan en la cola del grupo de subprocesos.

Hay un grupo de subprocesos por proceso. El grupo de subprocesos tiene un tamaño predeterminado de 25 subprocesos de trabajo por procesador disponible y 1000 subprocesos de finalización de E/S. El número de subprocesos del grupo de subprocesos se puede cambiar utilizando el método SetMaxThreads. Cada subproceso utiliza el tamaño de pila predeterminado y se ejecuta con la prioridad predeterminada.

NotaNota:

El código no administrado que aloja .NET Framework puede cambiar el tamaño del grupo de subprocesos utilizando la función CorSetMaxThreads definida en el archivo mscoree.h.

El grupo de subprocesos mantiene un número mínimo de subprocesos inactivos. Para los subprocesos de trabajo, el valor predeterminado de este mínimo es el número de procesadores. El método GetMinThreads obtiene los números mínimos de subprocesos de finalización de E/S y de trabajo inactivos.

Cuando todos los subprocesos del grupo de subprocesos se han asignado a tareas, dicho grupo no empieza a crear nuevos subprocesos inactivos inmediatamente. Para evitar la asignación innecesaria de espacio de pila para los subprocesos, crea nuevos subprocesos inactivos a intervalos. Actualmente el intervalo es de medio segundo, aunque puede cambiar en versiones futuras de .NET Framework.

Si una aplicación está sujeta a ráfagas de actividad en las que se colocan en la cola un gran número de tareas del grupo de subprocesos, utilice el método SetMinThreads para aumentar el número mínimo de subprocesos inactivos. De lo contrario, el retraso integrado al crear nuevos subprocesos inactivos podría crear un cuello de botella.

NotaNota:

Aumentar innecesariamente el número de subprocesos inactivos también puede producir problemas de rendimiento. Debe asignarse espacio de pila para cada subproceso. Si se inician demasiadas tareas al mismo tiempo, puede parecer que todas se realizan con lentitud. Encontrar el equilibrio correcto es un problema de ajuste del rendimiento.

TemaUbicación
Cómo: Crear un controlador HTTP asincrónicoGenerar aplicaciones Web ASP .NET en Visual Studio
Cómo: Crear un controlador HTTP asincrónicoGenerar aplicaciones Web ASP .NET

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." );
   
   // If you comment out the Sleep, the main thread exits before
   // the thread pool task runs.  The thread pool uses background
   // threads, which do not keep the application running.  (This
   // is a simple example of a race condition.)
   Thread::Sleep( 1000 );
   Console::WriteLine( "Main thread exits." );
   return 0;
}


import System.*;
import System.Threading.*;
import System.Threading.Thread;

public class Example
{
    public static void main(String[] args)
    {
        // Queue the task.
        ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc));
        Console.WriteLine("Main thread does some work, then sleeps.");

        // If you comment out the Sleep, the main thread exits before
        // the thread pool task runs.  The thread pool uses background
        // threads, which do not keep the application running.  (This
        // is a simple example of a race condition.)
        Thread.Sleep(1000);
        Console.WriteLine("Main thread exits.");
    } //main

    // 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.");
    } //ThreadProc
} //Example

System.Object
  System.Threading.ThreadPool

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows 98, Windows 2000 Service Pack 4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter

Microsoft .NET Framework 3.0 es compatible con Windows Vista, Microsoft Windows XP SP2 y Windows Server 2003 SP1.

.NET Framework

Compatible con: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0

XNA Framework

Compatible con: 1.0
Mostrar:
© 2014 Microsoft