Este artículo explica la tecnología de subprocesos de Java con más detalle con ejemplos. Creo que será útil para una comprensión profunda de la programación Java. Los detalles son los siguientes:
Muchas personas tienen cierta comprensión de los subprocesos cuando aprenden JAVA, y cuando comenzamos a contactar con el desarrollo de Android, realmente descubrimos lo importantes que son los subprocesos. Este artículo compartirá con usted la experiencia del uso de subprocesos de Java para su referencia.
En primer lugar, todos deben comprender que subprocesos y procesos no son lo mismo. ¿Qué es un proceso? El proceso es similar al que necesitamos para ejecutar el archivo de clase, y el subproceso es lo que realmente llama a los recursos de la CPU para que se ejecuten. Un archivo de clase generalmente tiene solo un proceso, pero puede haber muchos subprocesos. La ejecución de subprocesos es un método de ejecución asincrónico.
1. Cómo iniciar otro hilo en la función principal:
El código de muestra es el siguiente:
public class Thread_one { public static void main(String [] args){ Run run = new Run(); //run.run();// Esta es una llamada a un método, que es muy diferente de un hilo Thread thread = new Thread (run); thread.start();//Inicia el hilo y llama al método run() del hilo for(int i=1; i<=20; i++){ System.out.println("El valor de main hilo i: --------"+i); } }}class Run implements Runnable{ @Override public void run() { for(int i=1; i<=20; i++){ System.out .println( "El valor del subproceso i: "+i);2. El método de dormir en hilos.
El código de muestra es el siguiente:
clase pública Thread_sleep { /* * Pausa del hilo*/ public static void main(String [] args){ Runone run = new Runone(); hilo del hilo = new Thread(run). (5000); thread.interrupt();//Interrumpir la ejecución del hilo//thread.stop();//En comparación con interrumpir el hilo, detener es demasiado brusco y no se recomienda. Es necesario forzar el cierre del subproceso secundario. } catch (InterruptedException e) { e.printStackTrace(); } }}class Runone implements Runnable{ @Override public void run() { for(int i=1; i<10; i++). ){ intentar { Thread.sleep(1000 ); System.out.println("-----"+nueva fecha()+"-----" } catch (InterruptedException e) { return ;// Cuando se detecta que el hilo secundario está interrumpido, cierre el hilo secundario directamente} } }}Una nota especial aquí es que thread.interrupt(); puede interrumpir la ejecución de un hilo. Es un poco más suave que detenerlo, pero no es la mejor manera de cerrar un hilo.
clase pública Thread_stop { public static void main(String [] args){ Runtres run = new Runtres(); thread nuevo (ejecutar()); InterruptedException e) { e.printStackTrace(); } run.setStop(); }}class Runtres implementa Runnable{ bandera booleana; @Override public void run() { bandera = int i = 0; { System.out.println("hilo secundario----"+(i++)); Thread.sleep(1000); captura (InterruptedException e) { e.printStackTrace() } } } public void setStop(); bandera = falso; } }Permítanme presentarles brevemente la fusión y la donación en hilos:
1. Cómo fusionar hilos , aquí se llama al método join()
El código de muestra es el siguiente:
clase pública Thread_join { /* * Fusionar subprocesos*/ public static void main(String [] args){ Runtwo run = new Runtwo(); thread = new Thread(run); ();//Fusionar subprocesos, esto es equivalente a una llamada al método} catch (InterruptedException e) { e.printStackTrace(); } for(int i=0; i<10; i++){ System.out.println("main Hilo: "+i); } }}class Runtwo implements Runnable{ @Override public void run() { for(int i=0; i<10; i++){ System.out.println("Hilo secundario: --- -"+yo); } } }2. Cómo abandonar el hilo . Aquí se llama al método rendimiento () de Thread, como se muestra a continuación:
public class Thread_yield { /**Renunciar a la CPU * @param args */ public static void main(String[] args) { Th th = new Th("aaa"); ; i<=10; i++){ System.out.println("Hilo principal----"+i); } }}clase Th extiende Thread{ Th(){} Th(String s){super(s) ;} @Override public void run() { for(int i = 0; i<=10; i++){ if(i%3!=0){ System.out.println("hilo secundario"+i } else{ System.out.println("Sub-thread i="+i+" thread switch"); rendimiento();//Este método solo se puede utilizar si heredas de Thread} } }}Finalmente, me gustaría compartir con ustedes el tema de la prioridad del hilo . El código es el siguiente:
public class Thread_priority { /* * prioridad establece la prioridad del hilo * La prioridad predeterminada de Thread es 5, la prioridad máxima de Thread es 10 y la mínima es 0 */ public static void main(String [] args){ T1 t1; = new T1(); T2 t2 = new T2(); t1.start(); //t1.setPriority(Thread.NORM_PRIORITY+3); //Establece la prioridad de t1 t2.start(); extiende Thread { @Override public void run() { for(int i = 0; i<50; i++){ System.out.println("Thread T1-----"+i); Hilo{ @Override public void run() { for(int i = 0; i<50; i++){ System.out.println("Thread T2"+i);Creo que básicamente ha entendido el mecanismo de subprocesos en JAVA a través del código anterior. Espero que lo que describe este artículo le resulte útil en su estudio en profundidad de la programación Java.