Este artículo analiza cuatro usos de Java Thread Pool para su referencia. El contenido específico es el siguiente
1. Las desventajas del nuevo hilo
¿Todavía realiza un nuevo hilo de la siguiente manera al ejecutar una tarea asíncrona?
new Thread (new Runnable () {@Override public void run () {// TODO Método Generado automático}}). Start ();Entonces tendrá demasiadas salidas, las desventajas del nuevo hilo son las siguientes:
a. El rendimiento del nuevo hilo es pobre cada vez.
b. Los hilos carecen de gestión unificada, que pueden crear nuevos hilos sin restricciones, competir entre sí y pueden ocupar demasiados recursos del sistema para causar choques u Ooms.
do. Falta de más funciones, como ejecución cronometrada, ejecución periódica, interrupción de hilos.
En comparación con el nuevo hilo, las ventajas de las cuatro piscinas de hilos proporcionadas por Java son:
a. Reutilice los hilos existentes para reducir la sobrecarga de la creación y extinción de objetos, y desempeñarse bien.
b. Puede controlar efectivamente el número máximo de hilos concurrentes, mejorar la tasa de utilización de los recursos del sistema y evitar la competencia excesiva de recursos y evitar el bloqueo.
do. Proporciona funciones como ejecución cronometrada, ejecución regular, enhebrado único, control de números concurrentes, etc.
2. Java Hild Pool
Java proporciona cuatro tipos de grupos de hilos a través de ejecutores, a saber:
NewCachedThreadPool crea una piscina de hilos almacenables. Si la longitud de la piscina de rosca excede las necesidades de procesamiento, puede reciclar de manera flexible hilos inactivos. Si no hay reciclaje, cree un nuevo hilo.
NewFixedThreadPool crea un grupo de subprocesos de longitud fija que puede controlar el número máximo de concurrencia de subprocesos, y los hilos excesivos esperarán en la cola.
NewsCheduledThreadPool crea un grupo de hilos de longitud fija que admite la ejecución de tareas cronometradas y periódicas.
NewsingLethreadExecutor crea un grupo de hilos de un solo hilo, que solo usará un hilo de trabajador único para ejecutar tareas, asegurando que todas las tareas se ejecuten en el orden especificado (FIFO, LIFO, prioridad).
(1) NewCachedThreadPool:
Crea una piscina de hilo en caché. Si la longitud del grupo de roscas excede las necesidades de procesamiento, puede reciclar de manera flexible hilos inactivos. Si no hay reciclaje, cree un nuevo hilo. El código de muestra es el siguiente:
EjecutorService CachedThreadPool = Ejecutors.newCachedThreadPool (); for (int i = 0; i <10; i ++) {final int index = i; intente {Thread.sleep (índice * 1000); } catch (InterruptedException e) {E.PrintStackTrace (); } CachedthreadPool.Execute (new Runnable () {@OverridePublic Void run () {System.out.println (index);}});}La piscina de hilo es infinita. Cuando se ejecuta la segunda tarea, se ha completado la primera tarea, y el hilo que ejecuta la primera tarea se reutilizará sin crear un nuevo hilo cada vez.
(2) NewFixedThreadPool:
Cree un grupo de subprocesos de longitud fija que pueda controlar el número máximo de concurrencia de subprocesos, y los hilos excesivos esperarán en la cola. El código de muestra es el siguiente:
EjecutorService fiedThreadPool = Ejecutors.NewFixedThreadPool (3); for (int i = 0; i <10; i ++) {final int index = i; fijadoThreadPool.ExeCute (new runnable () {@OverridePublic Void run () {try {System.out.println (index); Thread.sleep (2000);} Catch (InterruptedException e) {// TODO Generated Catch E.PrintStackArtace ();}});}Debido a que el tamaño del grupo de subprocesos es de 3, duerme 2 segundos después del índice de salida de cada tarea, por lo que se imprimen 3 números cada dos segundos.
El tamaño de un grupo de subprocesos de longitud fija se establece mejor de acuerdo con los recursos del sistema. Como Runtime.getRuntime (). Disponible Processors (). Consulte PRELOADDATACACHE.
(3) NewsCheduledThreadPool:
Cree un grupo de subprocesos de longitud fija que admita la ejecución de tareas cronometradas y periódicas. El código de muestra para la ejecución retrasada es el siguiente:
ProgramedExecutorService ProchuledThreadPool = Ejecutors.newScheduledThreadPool (5); ProchuledThreadPool.schedule (new runnable () {@OverridePublic Void run () {System.out.println ("retraso 3 segundos");}}, 3, TimeUnit.SeConds);Indica la ejecución de retraso en 3 segundos.
El código de muestra se ejecuta regularmente de la siguiente manera:
ProchuledThreadPool.schedleeatFixedRate (new Runnable () {@OverridePublic Void run () {System.out.println ("retrasar 1 segundos y excluir cada 3 segundos");}}, 1, 3, TimeUnit.Seconds);Significa que el retraso se realiza cada 3 segundos después de 1 segundo.
ProgramedExecutorService es más seguro y más potente que el temporizador
(4) NewsingLethreadExecutor:
Cree un grupo de subprocesos único, que solo usará un hilo de trabajador único para ejecutar tareas, asegurando que todas las tareas se ejecuten en el orden especificado (FIFO, LIFO, Prioridad). El código de muestra es el siguiente:
EjecutorService SingLethreadExeCutor = Executors.NeWSingLetHreadExeCutor (); for (int i = 0; i <10; i ++) {final int index = i; singlethreadexeCutor.ExeCute (new runnable () {@OverridePublic Public run () {trey {system.ut.println (index); thread.Seat.Seat.Seat (2000); (InterruptedException e) {// toDO Generado en bloque E.PrintStackTrace ();Los resultados se producen en secuencia, que es equivalente a ejecutar cada tarea en secuencia.
La mayoría de los programas de GUI actuales son de un solo hilo. Los subprocesos únicos en Android se pueden usar para operaciones de bases de datos, operaciones de archivos, instalación por lotes de aplicaciones, eliminación por lotes de aplicaciones, etc., que no son adecuadas para concurrentes, pero pueden bloquear IO y afectar la respuesta de los subprocesos de UI.
La función del grupo de subprocesos:
La función de un grupo de subprocesos es limitar el número de subprocesos ejecutados en el sistema.
Dependiendo del entorno del sistema, el número de subprocesos se puede establecer automáticamente o manualmente para lograr el mejor efecto de operación; Se desperdician menos recursos del sistema y más congestión del sistema no es alta. Use un grupo de subprocesos para controlar el número de hilos, y otros hilos están esperando en línea. Después de ejecutar una tarea, la primera tarea se toma de la cola para comenzar la ejecución. Si no hay un proceso de espera en la cola, este recurso del grupo de hilos está esperando. Cuando se debe ejecutar una nueva tarea, si hay hilos de trabajadores que esperan en el grupo de subprocesos, puede comenzar a funcionar; De lo contrario, entrará en la cola de espera.
Por qué usar el grupo de hilos:
1. Reduce el número de veces que los hilos se crean y destruyen, y cada hilo de trabajador puede reutilizarse y puede realizar múltiples tareas.
2. El número de subprocesos de trabajadores en el grupo de subprocesos se puede ajustar de acuerdo con la capacidad del sistema para evitar que el servidor sea absorbido por el consumo de memoria excesivo (cada hilo requiere aproximadamente 1 MB de memoria. Cuanto más se abren los hilos, mayor será la memoria y finalmente el bloqueo será.
La interfaz de nivel superior del grupo de subprocesos en Java es el ejecutor, pero estrictamente hablando, el albacea no es un grupo de subprocesos, sino solo una herramienta para ejecutar hilos. La interfaz real del grupo de subprocesos es EjecutorService.
Varias categorías más importantes:
EjecutorService: una verdadera interfaz de grupo de subprocesos.
ProgramedExecutorService: puede ser similar a Timer/TimeTask, resolviendo problemas que requieren tareas repetidas.
ThreadPoolExecutor: la implementación predeterminada de ExecutorService.
ProchuledThreadPoolExecutor: una implementación de clase de la interfaz ProchuleDExecutorService que hereda ThreadPoolExecutor, una implementación de clase de programación de tareas periódicas.
Es bastante complicado configurar un grupo de subprocesos, especialmente cuando el principio del grupo de subprocesos no está muy claro. Es muy probable que el grupo de subprocesos configurado no sea mejor. Por lo tanto, algunas fábricas estáticas se proporcionan en la clase de ejecutores para generar algunos grupos de hilos de uso común.
1.NewsingLethreadExecutor
Crea un solo grupo de hilo. Este grupo de subprocesos solo tiene un hilo funcionando, que es equivalente a un solo hilo que realiza todas las tareas en serie. Si este hilo único termina debido a la excepción, entonces habrá un nuevo hilo para reemplazarlo. Este grupo de subprocesos asegura que la orden de ejecución de todas las tareas se ejecute en el orden de la presentación de la tarea.
2.NewfixedThreadPool
Cree un grupo de subprocesos de tamaño fijo. Cada vez que se envía una tarea, se crea un hilo hasta que el hilo alcanza el tamaño máximo del grupo de subprocesos. El tamaño del grupo de subprocesos sigue siendo el mismo una vez que alcanza su valor máximo. Si un hilo termina debido a una excepción de ejecución, el grupo de subprocesos agregará un nuevo hilo.
3.NewCachedThreadpool
Crea una piscina de hilo en caché. Si el tamaño del grupo de subprocesos excede el hilo requerido para procesar la tarea,
Luego se reciclarán algunos hilos inactivos (sin ejecución de tareas en 60 segundos). Cuando aumenta el número de tareas, este grupo de subprocesos puede agregar inteligentemente nuevos hilos para manejar la tarea. Este grupo de subprocesos no limita el tamaño del grupo de subprocesos, que depende completamente del tamaño máximo de hilo que el sistema operativo (o JVM) puede crear.
4.NewscheduledThreadPool
Cree un hilo de tamaño de tamaño ilimitado. Este grupo de hilos admite la necesidad de realizar tareas periódica y periódicamente.
Código de ejemplo
1. Grupo de subprocesos de tamaño fijo, NewFixedThreadPool:
paquete App.Executors; import java.util.concurrent.executors; import java.util.concurrent.executorservice; / ** * Java Thread: Hild Pool * * @author xiho */ public class test {public static void main (string [] args) {// Cree un grupo de hilos con un número fijo de hilos reutilizables EjecutorService Pool = Ejecutors.newFixedThreadPool (2); // Crear subproceso t1 = new MyThread (); Thread t2 = new MyThread (); Thread t3 = new MyThread (); Thread t4 = new MyThread (); Thread t5 = new MyThread (); // Ponga el hilo en la piscina para el grupo de ejecución.execute (T1); Pool.ExCute (T2); Pool.ExCute (T3); Pool.ExCute (T4); Pool.ExCute (T5); // Cierre la piscina de hilo.shutdown (); }} class myThread extiende el hilo {@Override public void run () {System.out.println (Thread.CurrentThread (). GetName () + "Ejecutando ..."); }}Resultado de salida:
Pool-1-Thread-1 se está ejecutando. . . Pool-1-Thread-3 se está ejecutando. . . Pool-1-Thread-4 se está ejecutando. . . Pool-1-Thread-2 se está ejecutando. . . Se está ejecutando Pool-1-Thread-5. . .
Cambie los parámetros en EjecutorService Pool = Ejecutors.NewFixedThreadPool (5): EjecutorService Pool = Ejecutors.NewFixedThreadPool (2), y el resultado de la salida es:
Pool-1-Thread-1 se está ejecutando. . . Pool-1-Thread-1 se está ejecutando. . . Pool-1-Thread-2 se está ejecutando. . . Pool-1-Thread-1 se está ejecutando. . . Pool-1-Thread-2 se está ejecutando. . .
De los resultados anteriores, podemos ver que el parámetro de NewfixedThreadPool especifica el número máximo de subprocesos que pueden ejecutarse. Después de agregar más que este número de hilos, no se ejecutarán. En segundo lugar, los hilos agregados al grupo de subprocesos están en el estado administrado, y la operación del hilo no se ve afectada por el orden de unión.
2. Grupo de hilo de tareas individuales, NewsingLethreadExecutor:
Simplemente cambie el ExecutorService Pool = Ejecutors.NewFixedThreadPool (2) en el código anterior a EjecutorService Pool = Ejecutors.NeWSingLethreadExecutor ();
Resultado de salida:
Pool-1-Thread-1 se está ejecutando. . . Pool-1-Thread-1 se está ejecutando. . . Pool-1-Thread-1 se está ejecutando. . . Pool-1-Thread-1 se está ejecutando. . . Pool-1-Thread-1 se está ejecutando. . .
Se puede ver que cada vez que llame al método de ejecución, el método de ejecución Thread-1 en realidad se llama al final.
3. Grupo de subprocesos de tamaño variable, NewCachedThreadPool:
Similar a lo anterior, simplemente cambie la forma en que se crea el grupo: ExecutorService Pool = Ejecutors.NewCachedThreadPool ();
Resultado de salida:
Pool-1-Thread-1 se está ejecutando. . . Pool-1-Thread-2 se está ejecutando. . . Pool-1-Thread-4 se está ejecutando. . . Pool-1-Thread-3 se está ejecutando. . . Se está ejecutando Pool-1-Thread-5. . .
Este método se caracteriza por el hecho de que se pueden crear nuevos grupos de subprocesos según sea necesario, pero se reutilizarán cuando estén disponibles hilos previamente construidos.
4. Delay Connection Pool, NewsCheduledThreadPool:
Public Class TestScheduledThreadPoolExecutor {public static void main (string [] args) {ProchuledThreadPoolExecutor Exec = new ProchuledThreadPoolExecutor (1); Exec.schedleatFixedRate (new Runnable () {// La excepción se activa de vez en cuando @Override publicvoid run () {// throLe new RuntimeException (); System.out.println ("============================================================================================================================================================================================================================================================================================ ¡ ================================================================================================================================================================================================. ================================================================================================================================================================================================. ================================================================================================================================================================================================. TimeUnit.milliseConds); exec.scheduleatfixedRate (new Runnable () {// Imprima el tiempo del sistema de vez en cuando, demostrando que los dos no tienen influencia en el otro @Override PublicVoid Run () {System.out.println (System.nanotime ());}, 1000, 2000, Timeunit.millis.Resultado de salida:
================ 838464454951683866438290348388643830710 =============== 8390643851388392643879319840064393938333
Lo anterior se trata de este artículo, espero que sea útil para el aprendizaje de todos.