¿Cuál es el uso de un grupo de subprocesos en Java?

Thread Pools de los tutoriales de Java tiene una buena visión general:

El uso de subprocesos de trabajo minimiza la sobrecarga debido a la creación de subprocesos. Los objetos Thread usan una cantidad significativa de memoria, y en una aplicación a gran escala, asignar y desasignar muchos objetos thread crea una sobrecarga de administración de memoria significativa.

Los grupos de subprocesos son útiles solo en un tipo de situación Servidor-cliente donde el número/ocurrencia de solicitudes de cliente no se puede determinar/predecir.

En este escenario, crear un nuevo Subproceso cada vez que se realiza una solicitud de cliente tiene dos ventajas:

1) Latencia de tiempo de ejecución para la creación de subprocesos: La creación de un hilo requiere algún tiempo, por lo que el trabajo real no comienza tan pronto como llega la solicitud. El cliente puede notar un ligero retraso.

Este criterio es crucial en sistemas interactivos, donde el cliente espera una acción inmediata.

2) Uso incontrolado de los Recursos del Sistema: Los hilos consumen recursos del sistema (memoria, etc.), por lo que el sistema puede quedarse sin recursos en caso de que haya un flujo sin precedentes de solicitudes de clientes.

Los grupos de subprocesos abordan las preocupaciones anteriores mediante:
1) Crear un número especificado de subprocesos en el inicio del servidor en lugar de crearlos durante el tiempo de ejecución.
2) Limitar el número de hilos que se están ejecutando en en cualquier momento.

Nota: Lo anterior es aplicable para Grupos de Hilos de Tamaños Fijos.

Puede asumir que los hilos son trabajadores reales y los grupos de hilos son un grupo de trabajadores. Puede crear varios grupos por varias razones, como prioridad, propósito, etc. Por lo tanto, mientras que un grupo puede ser para tareas de propósito general como horarios de fondo, difusión de correo electrónico, etc. puede haber un grupo de procesamiento de transacciones para procesar simultáneamente varias transacciones. En caso de un Servicio de Ejecutor, estoy seguro de que no le gustaría retrasar los trabajos transaccionales para ser completado después de otro las actividades no críticas, como los correos electrónicos de confirmación de difusión o las actividades de mantenimiento de la base de datos, no se completan. Puede segregarlos en piscinas y mantenerlos de forma independiente. Esa es una respuesta muy simplista sin entrar en jerga técnica. Respecto, KT

Una simple búsqueda en Google dará como resultado una gran cantidad de información sobre los grupos de subprocesos de Java y los grupos de subprocesos en general.

Aquí hay algunos enlaces útiles:

• Http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html

• Http://en.wikipedia.org/wiki/Thread_pool_pattern

Thread pool es un pool de subprocesos de trabajo ya creados listos para hacer el trabajo. Crea Thread y los administra. En lugar de crear subprocesos y descartarlos una vez que se realiza la tarea, thread-pool reutiliza subprocesos en forma de subproceso de trabajo.

Por Qué?

Porque la creación de Subprocesos es un proceso que consume mucho tiempo y retrasa el procesamiento de solicitudes. También limita el número de clientes en función de cuántos subprocesos por JVM se permite, que es obviamente un número limitado.

Crear un grupo de subprocesos de tamaño fijo usando Executor framework -

Java 5 introdujo un framework de grupo de subprocesos integrado con funciones completas comúnmente conocido como Executor framework .

Crear un grupo de subprocesos de tamaño fijo usando el framework Java 5 Executor es bastante fácil debido a los métodos de fábrica estáticos proporcionados por la clase Executors. Todo lo que necesita hacer es definir su tarea que desea ejecutar simultáneamente y luego enviar esa tarea a ExecutorService.

Desde aquí, Hilo pool se encargará de cómo ejecutar esa tarea; puede ser ejecutada por cualquier hilo de trabajo libre.

public class ThreadPoolExample {
    public static void main(String args[]) {
       ExecutorService service = Executors.newFixedThreadPool(10); //create 10 worker threads in Thread Pool
       for (int i =0; i<100; i++){
           service.submit(new Task(i)); //submit that to be done 
       }
    }  
}

final class Task implements Runnable {
    private int taskId;  
    public Task(int id){
        this.taskId = id;
    }

    @Override
    public void run() {
        System.out.println("Task ID : " + this.taskId +" performed by " 
                           + Thread.currentThread().getName());
    }  
}

Output:
Task ID : 0 performed by pool-1-thread-1
Task ID : 3 performed by pool-1-thread-4
Task ID : 2 performed by pool-1-thread-3
Task ID : 1 performed by pool-1-thread-2
Task ID : 5 performed by pool-1-thread-6
Task ID : 4 performed by pool-1-thread-5

*Output may vary from system to system