Thread Pool es una herramienta práctica para recopilar tareas en paralelo. Con la introducción de arquitecturas de múltiples núcleos adecuadas para la paralelización de la aplicación, el papel de los grupos de subprocesos se está volviendo cada vez más evidente. A través de la clase ThreadPoolExecutor y otras clases auxiliares, Java 5 introdujo este marco como una nueva sección de soporte de concurrencia.
El marco ThreadPoolExecutor es flexible y potente. Admite configuraciones específicas del usuario y proporciona ganchos relevantes y políticas de saturación para manejar las colas completas.
El grupo de hilos Java colocará las tareas enviadas primero en la cola de trabajo y las obtendrá de la cola de trabajo (el productor envía SynChroRousqueue directamente al hilo de trabajo). Luego hay dos estrategias de implementación para colas de trabajo: colas ilimitadas y colas limitadas. No hay ningún problema con la saturación en la cola ilimitada, pero el problema es que cuando la solicitud continúa siendo alta, la tarea se agregará a la cola de trabajo sin cerebro, lo que puede hacer que la memoria y otros recursos se desborden o se agoten. Las colas limitadas no causarán el agotamiento de la memoria causado por una alta carga, pero hay un problema de cómo administrar las tareas recién presentadas cuando la cola de trabajo está llena. Este es el problema que la estrategia de saturación de la cola de trabajo de trabajo de hilos necesita resolver.
Las estrategias de saturación se dividen en: Estrategia de abortes, estrategia de Callerruns, estrategia de descarga y estrategia de descarga.
Para una mejor comprensión, escribí un pequeño ejemplo.
paquete concurrencia.pool; import java.util.concurrent.linkedblockingDequ; import java.util.concurrent.rejedEdExecutionHandler; import java.util.concurrent.threadPoolExeCutor; import java.util.concurrent.timeunit; clase pública de clase pública saturación {/*** cuando el grupo de hilo es fulleue es fulle es fulle es fulle es fulle es fulle es fulle es fulle de thorue, lo que será un conjunto de pleno, lo que será un conjunto de thore. Bajo diferentes políticas de saturación* @param Handler Hilt Pool Work Política de saturación de la cola*/Política de voides estáticas públicas (RecheedExeCutionHandler Handler) {// Hay 2 subprocesos básicos, el número máximo de subprocesos es 3, y la capacidad de cola de trabajo es 5. ThreadPoolExecutor exec = new ThreadExecutor (2,3,0L, tiempo de tiempo. LinkedBlockingDeque <> (5)); if (Handler! = NULL) {Exec.SetRectedEdExeCutionHandler (Handler); // Establezca la política de saturación} para (int i = 0; i <10; i ++) {INSCRIME EXEC.SUBMIT (New Task ()); // Subt} Exec.shutdown ();} public static void Main (string [string [] args) » ThreadpoolexeCutor.abortPolicy ()); // Policy ((new ThreadPoolExeCutor.CallerRunSpolicy ())); // Policy (new ThreadPoolExeCutor.DiscardPolicy ()); // Policy (New ThreadPoolExeCutor.DisCardoldPolicy ();} // Class de Task Task Task de Task STATIC STATIC STATIC STATIC id = 0; // tarea id task () {id = ++ count;}@anverride public void run () {try {timeUnit.seconds.sleep (3); // dormir por 3 segundos} catch (interruptedException e) {system.err.err.println ("hilo fue interrumpido" + eggetMessage ();} system.out.prestln (task/"Task +" Task + "Task +" Task + "Task +" Thread: " + Thread.CurrentThread (). GetName () +" Ejecución completada ");}}} Cuando la cola de trabajo está llena, las diferentes estrategias se manejan de la siguiente manera:
1. Política de aborto: Política predeterminada. Cuando se envía una nueva tarea, la excepción sin control se lanza directamente. La excepción puede ser atrapada por la persona que llama.
Agregue el siguiente código a la función principal:
Política (nueva ThreadPoolExecutor.abortpolicy ());
El resultado de la operación es:
El programa lanza una EXCECCIÓN DE DIGNEDEXECUCIÓN, y se ejecutan un total de 8 tareas (el grupo de subprocesos puede ejecutar 3 tareas al principio, y 5 colas se almacenan en la cola de trabajo). Cuando la cola de trabajo está llena, se lanza directamente una excepción y el JVM no sale (no sé por qué ahora). Podemos ver que todos los hilos que ejecutan tareas son hilos en el grupo de subprocesos.
2. Estrategia de Callerruns: para el mecanismo de ajuste, ni abandonar tareas ni arrojar excepciones, sino que vuelve a la persona que llama. La nueva tarea no se ejecuta en el grupo de subprocesos, sino en el hilo llamando al exector.
Ejecutar en la función principal:
Política ((nueva ThreadPoolExeCutor.CallerRunSpolicy ()));
Resultados de ejecución
Todas las tareas se ejecutan y 2 (10 - 3 -5) tareas se ejecutan con éxito en el hilo principal, y 8 tareas son ejecutadas por hilos en el grupo de subprocesos.
3. Estrategia de descuento: las tareas recién presentadas se abandonan.
Ejecutar en la función principal
Política (nueva ThreadPoolExecutor.DiscoDPolicy ());
Los resultados anteriores muestran que no se presentan excepción, las 2 nuevas tareas enviadas más tarde se descartan, y solo se procesan las primeras 8 (3+5) tareas y las salidas JVM.
4. Estrategia más consecutiva: la cola es la tarea del "jefe del equipo" y luego intenta enviar una nueva tarea. (No es adecuado para escenarios de cola de trabajo como colas prioritarias)
Ejecute el siguiente método en la función principal
Política (new ThreadPoolExecutor.DiscardoldSpolicy ());
Resultado en ejecución: hay 8 tareas ejecutándose en total. El programa termina. Las tareas agregadas más tarde son 9 y 10, mientras que las tareas anteriores 3 y 4 se descartan.
Resumir
Lo anterior es todo el contenido de este artículo sobre el ejemplo del código de la estrategia de saturación de colas de trabajo de Java Thread Pool. Espero que sea útil para todos. Si hay alguna deficiencia, deje un mensaje para señalarlo. Gracias amigos por su apoyo para este sitio.