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

¿Cuál es el número máximo de hilos que puede crear en una aplicación C #? ¿Y qué pasa cuando alcanzas este límite? ¿Se lanza una excepción de algún tipo?

No hay límite inherente. El número máximo de subprocesos está determinado por la cantidad de recursos físicos disponibles. Vea este artículo de Raymond Chen para detalles.

Si necesita preguntar cuál es el número máximo de subprocesos, probablemente esté haciendo algo mal.

[ Actualización : solo por interés: .NET Thread Pool números predeterminados de hilos:

• 1023 en Framework 4.0 (entorno de 32 bits)
• 32767 en Framework 4.0 (entorno de 64 bits)
• 250 por núcleo en Framework 3.5
• 25 por núcleo en Framework 2.0

(Estos números pueden variar según el hardware y el sistema operativo)]

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

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

Sin embargo, como estamos en C #, si queremos ser completamente precisos, necesitamos distinguir entre hilos "iniciados" y "no iniciados". 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 el reflector si está interesado en los miembros reales).

Realmente puedes probarlo por ti mismo, compara:

    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)
        {
        }
    }

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

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

Me doy cuenta de que deberíamos usar el grupo de subprocesos, lo que hago, pero esta respuesta es en respuesta a la pregunta principal;)

Debería usar el grupo de subprocesos (o delegados asíncronos, que a su vez usan el grupo de subprocesos) para que el sistema pueda decidir cuántos subprocesos deben ejecutarse.

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

"Con la versión 2.0 del CLR, el número máximo de subprocesos de trabajo predeterminados a 25 por CPU en la máquina y el número máximo de subprocesos de E / S por defecto a 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 señaló @Mitch, esto es específico del CLR ThreadPool. Si está creando hilos directamente, vea los comentarios de @Mitch y otros.

Puede probarlo usando este código recortado:

private static void Main(string[] args)
{
   int threadCount = 0;
   try
   {
      for (int i = 0; i < int.MaxValue; i ++)
      {
         new Thread(() => Thread.Sleep(Timeout.Infinite)).Start();
         threadCount ++;
      }
   }
   catch
   {
      Console.WriteLine(threadCount);
      Console.ReadKey(true);
   }
}

Tenga cuidado con el modo de aplicación de 32 bits y 64 bits.

Recomendaría ejecutar el método ThreadPool.GetMaxThreads en depuración

ThreadPool.GetMaxThreads(out int workerThreadsCount, out int ioThreadsCount);

Documentos y ejemplos: https://docs.microsoft.com/en-us/dotnet/api/system.threading.threadpool.getmaxthreads?view=netframework-4.8