1. Conceptos básicos de hilos
Entendiendo de hilo: el hilo es una ruta de ejecución diferente en un programa
Cada rama se llama hilo, y main () se llama rama principal, también se llama hilo principal.
Un proceso es solo un concepto estático, un archivo .class en la máquina, un archivo .exe en la máquina, este se llama proceso. El proceso de ejecución del programa es así: primero, coloque el código del programa en el área de código de la memoria. Después de colocar el código en el área del código, no comienza a ejecutar de inmediato. Sin embargo, esto significa que un proceso está listo para comenzar. El proceso se ha generado, pero aún no ha comenzado a ejecutar. Este es el proceso, por lo que el proceso es en realidad un concepto estático y no se puede mover por sí mismo. La ejecución habitual del proceso se refiere al hilo principal en el proceso que comienza a ejecutar, es decir, el método main () comienza a ejecutarse. Los procesos son un concepto estático, y en realidad los hilos se ejecutan en nuestras máquinas.
El sistema operativo Windows admite múltiples subprocesos. Puede ejecutar muchos hilos al mismo tiempo y también admite múltiples procesos. Por lo tanto, el sistema operativo Windows es un sistema operativo que admite múltiples subprocesos y procesamiento múltiple. Linux y Uinux también son sistemas operativos que admiten múltiples subprocesos y procesamiento múltiple. DOS no admite múltiples subprocesos y procesamiento múltiple. Solo admite procesos únicos. Solo un proceso se está ejecutando en el mismo punto de tiempo, que se llama un solo hilo.
¿La CPU es realmente poderosa y capaz de ejecutar tantos programas al mismo tiempo? No, la ejecución de la CPU es la siguiente: la CPU es muy rápida, y se puede contar cientos de millones de veces en un segundo, por lo que la CPU divide su tiempo en pequeñas rodajas de tiempo. Ejecuto este tiempo Slice por un tiempo, la próxima vez que Slice lo ejecutará por un tiempo, y la próxima vez que Slice ejecutará a otros por un tiempo. Aunque hay docenas de hilos, se pueden ejecutarlos todos en muy poco tiempo. Pero para nosotros los humanos, la velocidad de ejecución de la CPU es demasiado rápida, por lo que parece que se está ejecutando al mismo tiempo, pero de hecho, en un momento, solo hay un hilo que se ejecuta en la CPU.
En primer lugar, debe comprender tres conceptos al aprender hilos :
1. Proceso: el proceso es un concepto estático
2. Hilo: hay un hilo principal en un proceso llamado método main (), que es un programa y una ruta de ejecución diferente en un proceso.
3. Al mismo tiempo, una CPU solo puede admitir un hilo para ejecutar. Debido a que la CPU se ejecuta muy rápido, parece que estamos multiproceso.
¿Qué es verdadero múltiple liquidación? Si su máquina tiene CPU duales o núcleos duales, de hecho es multiproceso.
2. Creación e inicio de hilos
En Java, los hilos de Java se implementan a través de la clase Java.lang.Thread, y cada objeto de hilo representa un nuevo hilo. Hay dos formas de crear un nuevo hilo: el primero es heredar de la clase de subprocesos, y la otra es implementar la interfaz ejecutable. Cuando comience la VM, habrá un hilo definido por el método principal (Public static void main ()), y este hilo se llama hilo principal. Se pueden crear nuevos hilos creando instancias de hilo. Solo necesita nuevo un objeto de hilo, y aparecerá un nuevo hilo. Cada subproceso completa su operación a través del método ejecutivo () correspondiente a un objeto de subproceso específico. El método run () se llama cuerpo del hilo.
Ejemplo 1: Crear e iniciar un nuevo hilo utilizando la implementación de la interfaz runnable
Crear un nuevo hilo para llamar al método Ejecutar
paquete cn.galc.test; public class testThread1 {public static void main (string args []) {runner1 r1 = new Runner1 (); // Aquí sale el nuevo objeto de la clase de subproceso // r1.run (); // Esto se llama una llamada de método. La ejecución de la llamada del método es esperar hasta ejecutar el método run () antes de que el método main () continúe ejecutándose. Hilo t = nuevo hilo (r1); // Para iniciar un nuevo hilo, debe salir el nuevo objeto de subproceso // hilo (destino runnable) se usa aquí. El constructor t.start (); // inicia el hilo recién abierto, el nuevo hilo ejecuta el método run (), y el nuevo hilo y el hilo principal se ejecutará en paralelo para (int i = 0; i <10; i ++) {system.out.println ("maintheod:"+i); }}}/*Defina una clase para implementar la interfaz ejecutable. La implementación de la interfaz runnable significa que esta clase es una clase de hilo*/class runner1 implementa runnable {public void run () {for (int i = 0; i <10; i ++) {system.out.println ("runner1:"+i); }}}El proceso de ejecución de los programas multiproceso es el siguiente:
Llame al método de ejecución directamente sin abrir un nuevo hilo
Los resultados de la operación son los siguientes:
Ejemplo 2: heredar la clase de hilo y anular su método run () para crear e iniciar un nuevo hilo
paquete cn.galc.test;/*El segundo método de creación e inicio de hilos: defina una subclase de hilo e implementa el método run ()*/public class testThread2 {public static void main (string args []) {rUnner2 r2 = new runner2 (); r2.start (); // llamar al método Start () para iniciar el hilo recién abierto para (int i = 0; i <= 10; i ++) {System.out.println ("MainMethod:"+i); }}}/*La clase Runner2 hereda de la clase de subprocesos instanciando un objeto de la clase Runner2, puede abrir un nuevo hilo. Llame al método Start () heredado de la clase de subprocesos. Puede iniciar el hilo recién abierto*/class runner2 extiende hilo {public void run () {// Reescribir la implementación del método run () para (int i = 0; i <= 10; i ++) {System.out.println ("Runner2:"+i); }}}La elección de usar dos métodos para crear nuevos hilos, a saber, implementar la interfaz ejecutable y heredar la clase de subprocesos, debe tener prioridad para abrir un nuevo hilo. Debido a que la implementación de una interfaz puede implementar múltiples, la herencia de una clase solo puede ser una sola herencia. Por lo tanto, cuando pueda usar la interfaz Runnable al abrir un nuevo hilo, intente no usar la herencia de la clase de subprocesos para abrir nuevos hilos.
3. Transición de estado de hilo
3.1. Métodos básicos de control de hilos
3.2. Introducción al método de sueño/unión/rendimiento
Ejemplo de aplicación del método de sueño:
paquete cn.galc.test; import java.util.*; public class testThread3 {public static void main (string args []) {myThread Thread = new MyThread (); thread.start (); // llame al método start () para iniciar el hilo recién abierto, try {/*thread.sleep(10000); El método Sleep () es un método estático declarado en la clase de subprocesos, por lo que puede usar el formato de Thread.sleep () para llamar * / /*MyThread.sleep(10000); La clase MyThread hereda la clase de hilo y naturalmente también hereda el método Sleep (), por lo que también puede llamarlo usando el formato de mythread.sleep () *// *La llamada de los métodos estáticos se puede llamar directamente en forma de "nombre de clase. Nombre del método estatal" o "referencia de objeto. System.out.println ("El hilo principal duerme durante 10 segundos y comienza nuevamente"); // Al llamar al método estático de otra clase en el método main (), debe usar el método "Class.static Method Nombre donde el método estático se encuentra" para llamar /*, así que aquí es dejar que el hilo principal duerma durante 10 segundos. Qué hilo llama al método Sleep (), por lo que ahora el hilo principal duerme. */} Catch (InterruptedException e) {E.PrintStackTrace (); } //thread.interrupt() ;//use interrupt () para finalizar la ejecución de un subproceso thread.flag = false; // Cambie las condiciones de bucle y finalice el bucle muerto/** * Cuando ocurra una Excepción InterruptedException, establezca directamente la condición de bucle en falso para salir del bucle muerto, * luego finalice la ejecución del hilo infantil. Esta es una mejor manera de finalizar el hilo infantil* / / *** Llamando al método de interrupción () para romper el hilo en funcionamiento es equivalente a verter una olla de agua fría en el hilo principal y romper el subproche de ejecución. Después de que se interrumpe el subproche de ejecución, se lanzará una Excepción InterruptedException, que ejecutará la instrucción de retorno y finalizará la ejecución del hilo. So the sub-thread here ends the execution of the thread after 10 seconds of execution*/ }}class MyThread extends Thread { boolean flag = true;// Define a tag to control the conditions of the loop public void run() { /* * Note: Here, you cannot write throw Exception directly behind the run() method to throw exceptions, * Because now we need to rewrite the run() method inherited from the Thread class, the rewrite method cannot Lanzar diferentes excepciones que el método reescrito. * Así que aquí solo puedes escribir try ... capt () para atrapar excepciones*/ while (bandera) { System.out.println("======================================================================================================== ================================================================= ================================================================= ================================================================= ================================================================= ================================================================= ================================================================== Por supuesto, no está mal llamarlo usando el formato de "nombre de clase. Nombre del método"*/ // mythread.sleep (1000); // Use el formato de "nombre de clase. Nombre del método" para llamar al método estático Duerme (1000); // Si se interrumpe durante el sueño, una hilo interrumpida se inicia aquí, aquí se inicia aquí, se inicia el segundo. Cada segundo en un bucle muerto, y el tiempo actual del sistema se imprime cada segundo} Catch (InterruptedException e) { /** Cuando duerme, una placa de agua fría puede interrumpir el sueño*, cuando el hilo en ejecución se interrumpe por algunas razones inesperadas, una excepción que se interrumpe (interruptaxception) puede ser lanzado* / return de regreso;Resultados de ejecución:
Ejemplo de método de unión:
paquete cn.galc.test; public class testThread4 {public static void main (string args []) {mythread2 thread2 = new myThread2 ("mythread"); // Al crear un nuevo objeto de subproceso, nombre el objeto de hilo mythread thread2.start (); // start thread try {thread2.Join (); // llame al método unión () para fusionar el hilo, fusionar el hilo infantil mythread en el hilo principal // después de fusionar el hilo, el proceso de ejecución del programa es equivalente al proceso de proceso del método del método} Catch (interruptException E) {E. {E. {E. {E.pread, el proceso de ejecución es equivalente al proceso del proceso de ejecución del método. } for (int i = 0; i <= 5; i ++) {System.out.println ("Soy el hilo principal"); }}} class myThread2 extiende el hilo {myThread2 (String s) {super (s); / * * Use la palabra clave súper para llamar al constructor de la clase principal * Uno de los constructores del hilo de la clase principal: "Public Thread (Nombre de cadena)" * A través de dicho constructor, el hilo recién abierto se puede nombrar, que facilita la gestión de hilos */} public void run () {for (int i = 1; i <= 5; i ++) {System.out.println ("" INT INT I = 1; i <5; i ++) {System.out.Println ("" INT INT I = 1; "I A/T", "". getName ()); // use // public Final String getName () definido en el hilo de la clase principal, devuelve el nombre de este hilo. Pruebe {dormir (1000); // Haga que el hilo del niño duerma durante 1 segundo cada vez que se ejecuta} Catch (InterruptedException e) {return; }}}}Resultados de ejecución:
Ejemplo de uso del método de rendimiento:
paquete cn.galc.test; public class testThread5 {public static void main (string args []) {mythread3 t1 = new myThread3 ("t1"); /* Dos hilos infantiles T1 y T2 se abrieron al mismo tiempo. T1 y T2 ejecutan el método run ()*//*Hay un total de 3 hilos en paralelo durante la ejecución de este programa, a saber, los hilos infantiles T1 y T2 y el hilo principal*/ mythread3 t2 = new Mythread3 ("T2"); t1.start (); // Starter Child Thread T1 T2.Start (); // Starter Child Thread T2 para (int i = 0; i <= 5; i ++) {System.out.println ("Soy el hilo principal"); }}} class myThread3 extiende el hilo {myThread3 (string s) {super (s); } public void run () {for (int i = 1; i <= 5; i ++) {system.out.println (getName () + ":" + i); if (i%2 == 0) {rendimiento (); // Cuando la ejecución alcanza la ejecución, se puede dividir por 2, la ejecución actual del subproceso se administra y deja que otro subproceso ejecute el método ejecutado () se ejecute primero/ * * puede ver durante el programa del programa, * cuando el subproceso se ejecuta (i%2 == 0) veces, dará el hilo y dejará que el hilo T2 se ejecute primero *, y cuando el hilo T1 se ejecute (i%2 == 0) veces, dará el hilo T2 y dejará que el hilo T2 se ejecute primero *, y cuando el hilo T1 se ejecute (i%2 == 0) veces, dará el hilo T2 y dejará que el hilo T2 se ejecute primero *, y cuando el hilo T1 se ejecute (i%2 == 0) veces, dará el hilo T2 y dejará que el hilo T2 se ejecute primero *, y cuando el subproceso se ejecute (i%2 == 0), se ejecutará el hilo T2. Times, entregará el hilo al hilo T1 a la ejecución de prioridad */}}}Los resultados de la operación son los siguientes:
Lo anterior es todo el contenido de este artículo. Esperamos que pueda ayudarlo.