Los siguientes ejemplos discuten principalmente dos temas:
Pregunta 1. El grupo de hilos tiene un tamaño fijo, suponiendo que es 5. Entonces, ¿cómo es el efecto de operación de colocar 10 hilos en la piscina de hilos? El estado de otros hilos?
Pregunta 2. Entonces, ¿cómo se quita un hilo de la piscina de hilo, o para ser precisos, para hacer que un hilo sea un hilo inactivo?
ejemplo:
paquete com.dada.executorservice; import java.util.concurrent.timeunit; Public Class JobThread extiende el hilo {// Nombre el hilo public JobThread (name de cadena, long threadid) {super (nombre); } @Override public void run () {// Si el hilo principal contiene este hilo, se ejecutará while (mainthread.threadnamEmap.containskey (this.getName ()))) {try {System.out.println ("Nombre de hilo: -----" + this.getName ()); TimeUnit.seconds.Seep (4); } catch (Exception e) {E.PrintStackTrace (); }} System.out.println ("******************** La subproceso, el nombre del hilo: *****************" + this.getName ()); }} paquete com.dada.executorservice; import java.util.hashmap; import java.util.concurrent.executorservice; import java.util.concurrent.executors; import java.util.concurrent.timeunit; clase pública MainThread {public static final int threadpool_size = 5; // Generar un grupo de hilo de tamaño fijo public static staticsorService exec = ejecutors.newfixedthreadpool (threadpool_size); // mapa utilizado para almacenar nombres de subprocesos mapa estático público <string, string> threadnamEmap = new Hashmap <String, String> (); public static void main (string [] args) {// Inserte 10 roscos en el grupo de roscas, pero el grupo de roscas solo permite un máximo de 5 hilos, por lo que los otros 5 hilos están esperando (int i = 0; i <threadpool_size+5; i ++) {string shedname = getThreadName (i); threadnamEmap.put (ThreadName, ThreadName); exec.Execute (nuevo JobThread (ThreadName, I)); } System.out.println ("Tamaño de la tabla hash:" + threadnamEmap.size ()); intente {System.out.println ("¡El hilo principal duerme por un tiempo!"); TimeUnit.Seconds.Seep (3); } catch (Exception e) {E.PrintStackTrace (); System.out.println ("¡Despierta!"); } // Los siguientes se usan para eliminar los hilos en el grupo de subprocesos // eliminar (0); // eliminar (1); // eliminar (2); } public static void eliminar (int i) {threadnamEmap.remove (getThreadName (i)); System.out.println ("Eliminar Threadthread" + i + ", el tamaño de la tabla hash:" + threadnamEmap.size ()); } public static string getThreadName (int i) {return "ThreadName"+i; }} Ejecute directamente el resultado del código:
ThreadName: ------ ThreadName0
El tamaño de la tabla hash: 10
¡Duerme por un tiempo en el hilo principal!
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName4
en conclusión:
Encontrado impreso: el nombre del hilo ha sido de ThreadName0 a ThreadName4, ningún otro nombre.
Se demuestra que se colocan 10 hilos en la piscina de hilos, pero el tamaño de la piscina de hilo es 5, y solo se pueden asignar 5 hilos CPU. El en funcionamiento es el primero en poner en el grupo de hilos, y los otros hilos están en el estado listo (estado de bloqueo).
Después de eliminar los comentarios, se ejecuta el código:
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName4
El tamaño de la tabla hash: 10
¡Duerme por un tiempo en el hilo principal!
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
Eliminar el hilo de hilo0, el tamaño de la tabla hash: 9
Eliminar el subproceso de hilo1, el tamaño de la tabla hash: 8
Eliminar el subproceso de hilo2, el tamaño de la tabla hash: 7
*************** La hilo finaliza el hilo: *********** ThreadName2
***************** Los hilos, Nombre del hilo: *********** ThreadName0
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName6
*************** Los hilos finalizan el hilo: *********** ThreadName1
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName6
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName6
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName3
en conclusión:
A partir de los resultados, podemos ver que antes de quitar el hilo, el hilo en ejecución todavía está desde Thread0 a Thread4. Después de eliminar el subproceso de hilo 0, el nuevo subproceso 3 comienza a funcionar, y va a ThreadName7 en orden.
El resumen es el siguiente:
1. La piscina de hilo es fija en tamaño, suponiendo que es 5. Entonces, ¿cómo es el efecto de operación de colocar 10 hilos en la piscina de hilos? El estado de otros hilos?
a. El concepto de grupo de subprocesos es que sigue presionando las solicitudes, pero solo puede manejar los hilos con cuotas especificadas, y los hilos adicionales esperarán en él.
b. Cuando uno de los subprocesos ha completado el procesamiento (la ejecución del negocio se completa o el bucle mientras está salido), el grupo de subprocesos eliminará automáticamente un trabajo de la cola de espera y usará un hilo inactivo para ejecutar el trabajo. Qué grupo de hilos en la piscina de hilo en ejecución debe basarse en el orden en el que se coloca.
2. Entonces, ¿cómo eliminar un hilo de la piscina de hilo, o para ser precisos, para hacer que un hilo sea un hilo inactivo?
El grupo de hilos no puede obtener uno de los hilos y matarlo porque el hilo principal que usa el grupo de hilos y los hilos abridos por el hilo principal están en el mismo nivel, y nadie tiene derecho a dominar la supervivencia de la otra parte. Pero puede cambiar el método y lograr el objetivo de manera táctea.
a. El hilo principal mantiene una tabla hash que puede ser un hashmap. El valor clave es arbitrario, pero debe ser único y puede indicar de manera única un hilo.
b. Todos los hilos colocados en el grupo de subprocesos deben generar un valor clave y luego almacenarlo en este hashmap.
do. Para hilos de clase de bucle, como hilos de While (verdadero). Se debe agregar una condición para verificar si la clave de este hilo existe en el hashmap anterior. Salga del bucle While si no existe.
d. Aunque el hilo principal no puede dominar la supervivencia de otros hilos, puede colocar o eliminar su propio hashmap. En este punto, siempre y cuando el valor clave correspondiente del hilo se elimine del hashmap, el hilo saldrá automáticamente la próxima vez que brote.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.