Hilo vs ThreadPool

El threadpool administrado por. NET: -

• Los tamaños se basan en la carga de trabajo actual y el hardware disponible
• Contiene hilos de trabajo y hilos de puerto de finalización (que se usan específicamente para dar servicio a IO)
• Está optimizado para un gran número de operaciones de vida relativamente corta

Existen otras implementaciones de grupos de subprocesos que podrían ser más apropiadas para operaciones de larga duración.

Específicamente, use un grupo de subprocesos para evitar que su aplicación de crear demasiados hilos. La característica más importante de un threadpool es la cola de trabajo. Es decir, una vez que su máquina esté lo suficientemente ocupada, el threadpool pondrá en cola las solicitudes en lugar de generar inmediatamente más subprocesos.

Por lo tanto, si va a crear un pequeño número limitado de hilos, créelos usted mismo. Si no puede determinar por adelantado cuántos hilos se pueden crear (por ejemplo, se crean en respuesta a IO entrante), y su trabajo será de corta duración, use el threadpool. Si no sabe cuántos, pero su trabajo será de larga duración, no hay nada en la plataforma que lo ayude, pero es posible que pueda encontrar implementaciones alternativas de threadpool que se ajusten.

También

new Thread().Start()

Genera un hilo en primer plano que no morirá si cierras el programa. Los subprocesos ThreadPool son subprocesos en segundo plano que mueren al cerrar la aplicación.

Estaba curiosidades sobre el uso relativo de recursos para estos y y corrió un punto de referencia en mi 2012 de doble núcleo Intel i5 portátil utilizando.net 4.0 versión construir en Windows 8. Los grupos de hilos tomaron en promedio 0.035 ms para comenzar donde los hilos tomaron un promedio de 5.06 ms. En otras palabras, el hilo en el grupo comenzó aproximadamente 300 veces más rápido para un gran número de hilos de corta duración. Al menos en el rango probado (100-2000) hilos, el tiempo total por hilo parecía bastante constante.

Este es el código que fue referencia:

    for (int i = 0; i < ThreadCount; i++) {
        Task.Run(() => { });
    }

    for (int i = 0; i < ThreadCount; i++) {
        var t = new Thread(() => { });
        t.Start();
    }

Compruebe aquí para un hilo anterior:

¿Cuándo no debo usar ThreadPool en. Net?

El resumen es que Threadpool es bueno si necesitas generar muchos subprocesos de corta duración, mientras que usar Subprocesos te da un poco más de control.

El almacenamiento local de subprocesos no es una buena idea con grupos de subprocesos. Da a los hilos una "identidad"; ya no todos los hilos son iguales. Ahora los grupos de subprocesos son especialmente útiles si solo necesita un montón de subprocesos idénticos, listos para hacer su trabajo sin sobrecarga de creación.

Si necesitas muchos hilos, probablemente quieras usar un ThreadPool. Reutilizan hilos ahorrándole la sobrecarga de la creación de hilos.

Si solo necesitas un hilo para hacer algo, el hilo es probablemente el más fácil.

La necesidad principal de los subprocesos de adpool es manejar pequeñas tareas cortas que se espera que se completen casi instantáneamente. Los manejadores de interrupciones de hardware a menudo se ejecutan en un contexto de apilamiento que no sería adecuado para código no del núcleo, pero un manejador de interrupciones de hardware puede descubrir que una devolución de llamada de finalización de E/S en modo de usuario debe ejecutarse tan pronto como sea posible. Crear un nuevo hilo con el propósito de ejecutar tal cosa sería una exageración masiva. Tener algunos hilos pre-creados que pueden ser despachado para ejecutar devoluciones de llamada de finalización de E/S u otras cosas similares es mucho más eficiente.

Un aspecto clave de tales subprocesos es que si los métodos de finalización de E/S siempre se completan esencialmente instantáneamente y nunca se bloquean, y el número de dichos subprocesos que actualmente están ejecutando dichos métodos es al menos igual al número de procesadores, la única manera en que cualquier otro subproceso podría ejecutarse antes de que uno de los métodos mencionados termine el tiempo excede un corte de tiempo de roscado normal; ninguno de estos debe ocurrir muy a menudo si el grupo de subprocesos se utiliza como se pretende.

Si no se puede esperar que un método salga dentro de los 100 ms aproximadamente de cuando comienza la ejecución, el método debe ejecutarse a través de algún medio que no sea el grupo de subprocesos principal. Si uno tiene muchas tareas que realizar que son intensivas en CPU pero no se bloquean, puede ser útil despacharlas usando un grupo de subprocesos de aplicaciones (uno por núcleo de CPU) que está separado del threadpool "principal", ya que usar más subprocesos que núcleos será contraproducente cuando se ejecuten tareas que no bloqueen el uso intensivo de CPU. Sin embargo, si un método tarda un segundo o más en ejecutarse, y pasa la mayor parte de su tiempo bloqueado, es probable que el método se ejecute en un subproceso dedicado, y es casi seguro que no se ejecute en un subproceso main-threadpool. Si una operación de larga duración necesita ser activada por algo como una devolución de llamada de E/ S, uno debe iniciar un subproceso para la operación de larga duración operation in advance of the callback and have it wait on a monitor which the callback pulses, or else have the callback launch a new thread to perform the operation while the callback exits, effectively returning its own thread to the threadpool.

En general (nunca he usado.NET), se usaría un grupo de subprocesos para fines de administración de recursos. Permite configurar restricciones en su software. También se puede hacer por razones de rendimiento, ya que la creación de nuevos hilos puede ser costosa.

También puede haber razones específicas del sistema. En Java (de nuevo, no se si esto se aplica a. NET), el administrador de los subprocesos puede aplicar variables específicas de subprocesos a medida que cada subproceso se extrae del grupo, y desajustarlos cuando son devuelto (forma común de pasar algo como una identidad).

Restricción de ejemplo: Solo tengo conexiones de 10 db, por lo que solo permitiría 10 hilos de trabajo para acceder a la base de datos.

Esto no significa que no debas crear tus propios hilos, pero hay condiciones bajo las cuales tiene sentido usar un pool.

Usar un pool es una buena idea, si no sabes o no puedes controlar cuántos subprocesos se crearán.

Solo tiene un problema con un formulario que usa thread para actualizar algún campo de una base de datos en un evento positionchanged de un control de lista(evite freez). Le tomó 5 minutos a mi usuario tener un error de la base de datos (demasiadas conexiones con Access) porque estaba cambiando la posición de la lista demasiado rápido...

Sé que hay otra forma de resolver el problema base (incluyendo no usar acceso), pero la agrupación es un buen comienzo.