multithreading - español - thread pool java
Thread Pool vs Thread Spawning (11)
¿Alguien puede enumerar algunos puntos de comparación entre Thread Spawning vs Thread Pooling, cuál es mejor? Considere el .NET Framework como una implementación de referencia que admite ambos.
Depende de lo que quieras ejecutar en el otro hilo.
Para tareas cortas, es mejor usar un grupo de subprocesos, para tareas largas puede ser mejor generar un nuevo hilo, ya que podría hacer que el grupo de subprocesos se quede sin alimentos para otras tareas.
Esta answer es un buen resumen, pero por las dudas, aquí está el enlace a Wikipedia:
Hay poco tiempo adicional requerido para crear / generar subprocesos, donde la encuesta de subprocesos ya contiene subprocesos creados que están listos para ser utilizados.
La principal diferencia es que un ThreadPool mantiene un conjunto de hilos que ya están configurados y disponibles para su uso, ya que iniciar un nuevo hilo puede ser costoso para el procesador.
Sin embargo, tenga en cuenta que incluso un ThreadPool necesita "generar" subprocesos ... generalmente depende de la carga de trabajo: si hay mucho trabajo por hacer, un buen conjunto de subprocesos creará nuevos subprocesos para manejar la carga según la configuración y los recursos del sistema. .
Los subprocesos de grupo de subprocesos son mucho más baratos que un subproceso normal, agrupan los recursos del sistema necesarios para los subprocesos. Pero tienen una serie de limitaciones que pueden hacer que no sean aptos:
- No puedes abortar un hilo de threadpool
- No hay una manera fácil de detectar que se haya completado un conjunto de subprocesos, sin Thread.Join ()
- No hay una forma fácil de ordenar excepciones de un hilo de subprocesos
- No puede mostrar ningún tipo de interfaz de usuario en un subproceso de subprocesos más allá de un cuadro de mensaje
- Un subproceso de subprocesos no debe ejecutarse más de unos pocos segundos
- Un hilo de threadpool no debe bloquear durante mucho tiempo
Las últimas dos restricciones son un efecto secundario del programador de subprocesos, que intenta limitar el número de subprocesos activos al número de núcleos que su CPU tiene disponibles. Esto puede causar largos retrasos si programa muchos subprocesos de larga ejecución que se bloquean a menudo.
Muchas otras implementaciones de subprocesos tienen restricciones similares, dar o recibir.
Mi sensación es que deberías comenzar simplemente creando un subproceso según sea necesario ... Si el rendimiento de esto es correcto, entonces has terminado. Si en algún momento, detecta que necesita una menor latencia en la creación de subprocesos, generalmente puede colocar un grupo de subprocesos sin romper nada ...
Para alguna definición de "mejor", generalmente quiere ir con un grupo de subprocesos. Sin saber cuál es su caso de uso, tenga en cuenta que con un grupo de subprocesos, tiene un número fijo de subprocesos que se pueden crear al inicio o se pueden crear a pedido (pero el número de subprocesos no puede exceder el tamaño del grupo). Si se envía una tarea y no hay un subproceso disponible, se pone en una cola hasta que haya un subproceso libre para manejarlo.
Si está generando subprocesos en respuesta a solicitudes o algún otro tipo de desencadenante, se corre el riesgo de agotar todos sus recursos, ya que no hay nada que limite la cantidad de subprocesos creados.
Otro beneficio de la agrupación de subprocesos es la reutilización: los mismos subprocesos se utilizan una y otra vez para manejar diferentes tareas, en lugar de tener que crear un nuevo subproceso cada vez.
Como han señalado otros, si tiene una pequeña cantidad de tareas que se ejecutarán durante mucho tiempo, esto anularía los beneficios obtenidos al evitar la creación frecuente de subprocesos (ya que de todos modos no tendría que crear una tonelada de subprocesos).
Para la ejecución de subprocesos múltiples combinada con la obtención de valores de retorno de la ejecución, o una manera fácil de detectar que un conjunto de subprocesos se ha completado, se pueden usar los callables java.
Consulte https://blogs.oracle.com/CoreJavaTechTips/entry/get_netbeans_6 para obtener más información.
Todo depende de tu escenario. Crear nuevos hilos requiere muchos recursos y es una operación costosa. La mayoría de las operaciones asíncronas muy cortas (menos de unos pocos segundos como máximo) podrían hacer uso del grupo de subprocesos.
Para las operaciones de ejecución más larga que desea ejecutar en segundo plano, normalmente creará (generará) su propio hilo. (Ab) el uso de un conjunto de subprocesos integrado de plataforma / tiempo de ejecución para operaciones de larga ejecución podría llevar a formas desagradables de puntos muertos, etc.
Un "grupo" contiene una lista de "subprocesos" disponibles listos para ser utilizados, mientras que "generar" se refiere a la creación de un nuevo subproceso.
La utilidad de "Thread Pooling" reside en "menor tiempo de uso": se evita la sobrecarga de tiempo de creación.
En términos de "cuál es mejor": depende. Si la sobrecarga de tiempo de creación es un problema, use Thread-pooling. Este es un problema común en entornos donde se deben realizar muchas "tareas de corta duración".
Como han señalado otras personas, hay una "sobrecarga de administración" para la agrupación de subprocesos: esto es mínimo si se implementa correctamente. Por ejemplo, limitar el número de subprocesos en la agrupación es trivial.
La agrupación de subprocesos generalmente se considera mejor, porque los subprocesos se crean por adelantado y se usan según sea necesario. Por lo tanto, si usa muchos hilos para tareas relativamente cortas, puede ser mucho más rápido. Esto se debe a que se guardan para uso futuro y no se destruyen y luego se vuelven a crear.
Por el contrario, si solo necesita 2-3 subprocesos y solo se crearán una vez, entonces esto será mejor. Esto se debe a que no obtiene beneficios al almacenar en caché los subprocesos existentes para su uso futuro, y no está creando subprocesos adicionales que no se pueden usar.