¿Número máximo de subprocesos en una aplicación .NET?

Question

¿Cuál es la cantidad máxima de hilos que puede crear en una aplicación C#? ¿Y qué pasa cuando alcanzas este límite? Es una excepción de algún tipo arrojado?

Answer 1

No hay límite inherente. La cantidad máxima de subprocesos está determinada por la cantidad de recursos físicos disponibles. Consulte esto article by Raymond Chen para detalles.

Si necesita preguntar cuál es la cantidad máxima de hilos, probablemente esté haciendo algo mal.

[actualización: Solo por curiosidad: .NET subproceso del grupo de números predeterminados de hilos:

• 1023 en Framework 4.0 (entorno de 32 bits)
• 32768 en Framework 4.0 (64 bits medio ambiente)
• 250 por núcleo en el Marco 3.5
• 25 por núcleo en el Marco 2,0

(Estos números pueden variar dependiendo del hardware y OS)]

Answer 2

Jeff Richter en CLR a través de C#:

"Con la versión 2.0 de la CLR, el máximo número de defecto subprocesos de trabajo al 25 por CPU en la máquina y el número máximo de E/S hilos tiene como valor predeterminado 1000. Un límite de 1000 es efectivamente ningún límite. "

Tenga en cuenta que esto se basa en .NET 2.0. Esto puede haber cambiado en .NET 3.5.

[Editar] Como @Mitch señaló, esto es específico de la CLR ThreadPool. Si está creando hilos directamente, vea @Mitch y otros comentarios.

Answer 3

Mitch tiene razón. Depende de los recursos (memoria).

Aunque el artículo de Raymond está dedicado a subprocesos de Windows, no a subprocesos de C#, la lógica aplica lo mismo (los subprocesos de C# se asignan a subprocesos de Windows).

Sin embargo, como estamos en C#, si queremos ser completamente precisos, debemos distinguir entre los hilos "iniciado" y "no iniciado". Solo los hilos iniciados en realidad reservan espacio de pila (como podríamos esperar). Los subprocesos no iniciados solo asignan la información requerida por un objeto de subproceso (puede usar reflector si está interesado en los miembros reales).

En realidad se puede comprobar por sí mismo, comparar:

static void DummyCall() 
    { 
     Thread.Sleep(1000000000); 
    } 

    static void Main(string[] args) 
    { 
     int count = 0; 
     var threadList = new List<Thread>(); 
     try 
     { 
      while (true) 
      { 
       Thread newThread = new Thread(new ThreadStart(DummyCall), 1024); 
       newThread.Start(); 
       threadList.Add(newThread); 
       count++; 
      } 
     } 
     catch (Exception ex) 
     { 
     } 
    } 

con:

static void DummyCall() 
    { 
     Thread.Sleep(1000000000); 
    } 

    static void Main(string[] args) 
    { 
     int count = 0; 
     var threadList = new List<Thread>(); 
     try 
     { 
      while (true) 
      { 
       Thread newThread = new Thread(new ThreadStart(DummyCall), 1024); 
       threadList.Add(newThread); 
       count++; 
      } 
     } 
     catch (Exception ex) 
     { 
     } 
    } 

Deja un punto de interrupción en la excepción (fuera de la memoria, por supuesto) en VS para ver el valor de contador. Hay una diferencia muy significativa, por supuesto.

Answer 4

Debe utilizar el grupo de subprocesos (o delegados asincrónicos, que a su vez usan el grupo de subprocesos) para que el sistema pueda decidir cuántos subprocesos se deben ejecutar.

Answer 5

hice una prueba en un sistema de 64 bits con consola C#, la excepción es el tipo de falta de memoria, con 2949 hilos.

Me di cuenta que deberíamos usar la piscina de roscado, lo que hago, pero esta respuesta es una respuesta a la pregunta principal;)