Resumen de aprendizaje de Java: 27

Métodos comunes de operación de subprocesos múltiples

Nombramiento y adquisición de hilos

Debido a que el estado de subprocesamiento múltiple es incierto, el nombre del subproceso se convierte en la única marca distintiva. Al definir el nombre del subproceso, debe establecer el nombre antes de que comience el subproceso. Intente no duplicar el nombre e intente no modificar el subproceso que se ha iniciado. Nombre
Debido al estado incierto del hilo, cada vez que puede operar un hilo que está ejecutando el método run (), el método para obtener el objeto de hilo actual es: hilo estático público hilo actual ().

Ejemplo: observar el nombre de los hilos

package Project.Study.Multithreading;
class MyTread4 implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName());//使用currentThread()取得当前线程对象后再取得具体的线程名字
    }
}
public class Test4 {
    public static void main(String [] args) throws Exception{
        MyTread4 mt=new MyTread4();
        new Thread(mt,"自己的线程A").start();
        new Thread(mt).start();
        new Thread(mt,"自己的线程B").start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}
//结果：
//自己的线程A
//Thread-1
//自己的线程B
//Thread-0
//Thread-2

Ejemplo: obtener el nombre del hilo

package Project.Study.Multithreading;
class MyTread4 implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName());//使用currentThread()取得当前线程对象后再取得具体的线程名字
    }
}
public class Test4 {
    public static void main(String [] args) throws Exception{
        MyTread4 mt=new MyTread4();
        new Thread(mt,"自己的线程A").start();
        new Thread(mt).start();
        mt.run();
    }
}
//结果：
//main
//自己的线程A
//Thread-0

A través de este programa podemos encontrar que el método principal en sí también pertenece a un hilo.
Cada proceso JVM inicia al menos los siguientes dos hilos:
1. hilo principal: la ejecución principal del programa e inicia la subrutina,
2. hilo gc: responsable de la recolección de basura.

Hilo de dormir

La suspensión del subproceso se refiere a hacer que la velocidad de ejecución del programa sea más lenta.El método de operación de suspensión del subproceso en la clase de subproceso es: el sueño de vacío público estático (largos milis) arroja la Interrupción Excepción, y la unidad de suspensión establecida es milisegundos (ms).
Ejemplo: observar las características del sueño

package Project.Study.Multithreading;

class MyThread5 implements Runnable{
    @Override
    public void run(){
        for (int x=0;x<10;x++){
            try {
                Thread.sleep(1000);     		//每次执行休眠1s
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+",x="+x);
        }
    }
}
public class Test5 {
    public static void main(String []args){
        MyThread5 mt1=new MyThread5();
        MyThread5 mt2=new MyThread5();
        MyThread5 mt3=new MyThread5();
        new Thread(mt1,"自己的线程对象A").start();
        new Thread(mt2,"自己的线程对象B").start();
        new Thread(mt3,"自己的线程对象C").start();
    }
}
//结果：
//自己的线程对象B,x=0
//自己的线程对象A,x=0
//自己的线程对象C,x=0
//自己的线程对象A,x=1
//自己的线程对象B,x=1
//自己的线程对象C,x=1
//自己的线程对象B,x=2
//自己的线程对象A,x=2
//自己的线程对象C,x=2
//...
//自己的线程对象C,x=9
//自己的线程对象B,x=9
//自己的线程对象A,x=9

El resultado del programa anterior es tres y tres salidas (en realidad una ilusión). Se emiten tres objetos de hilo cada segundo. Debido a que la velocidad de cambio de hilo es demasiado rápida, habrá una forma en que todos los hilos ingresen al método run () al mismo tiempo. El sentimiento, pero de hecho hay una brecha.

Prioridad de hilo

En la operación de subproceso de Java, el subproceso con la prioridad más alta se puede ejecutar primero. La prioridad del hilo se muestra a continuación:
Operación de prioridad del hilo

No.	Método o constante	Tipo	Descripción
1	public static final int MAX_PRIORITY	Constante	Máxima prioridad, el valor es 10
2	public static final int NORM_PRIORITY	Constante	Prioridad media, valor 5
3	public static final int MIN_PRIORITY	Constante	La prioridad más baja, el valor es 1
4 4	public final void setPriority (int nueva prioridad)	Ordinario	Establecer prioridad de hilo
5 5	public final int getPriority ();	Ordinario	Obtener prioridad de hilo

Ejemplo: establecer la prioridad del hilo

package Project.Study.Multithreading;

class MyThread6 implements Runnable{
    @Override
    public void run(){
        for(int x=0;x<20;x++){
            try {
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+",x="+x);
        }
    }
}
public class Test6 {
    public static void main(String [] args){
        MyThread6 mt1 = new MyThread6();
        Thread t1 = new Thread(mt1,"自己的线程对象A");
        Thread t2= new Thread(mt1,"自己的线程对象B");
        Thread t3=new Thread(mt1,"自己的线程对象C");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t3.setPriority(Thread.NORM_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    }
}
//结果：
//自己的线程对象C,x=0
//自己的线程对象A,x=0
//自己的线程对象B,x=0
//自己的线程对象A,x=1
//自己的线程对象C,x=1
//自己的线程对象B,x=1
//自己的线程对象C,x=2
//自己的线程对象A,x=2
//自己的线程对象B,x=2
//自己的线程对象B,x=3
//自己的线程对象C,x=3
//自己的线程对象A,x=3
//自己的线程对象B,x=4
//自己的线程对象A,x=4
//自己的线程对象C,x=4
//...
//自己的线程对象C,x=19
//自己的线程对象B,x=19
//自己的线程对象A,x=19

Se puede ver a partir de los resultados de ejecución que el orden de ejecución de los subprocesos no necesariamente se puede ejecutar de acuerdo con la prioridad establecida, porque los subprocesos no necesariamente pueden obtener recursos de la CPU.

Consulta: Prioridad del método principal

public class Test6 {
    public static void main(String [] args){
        System.out.println(Thread.currentThread().getPriority());
    }
}
//结果：
//5

Se puede ver que la prioridad del método principal es 5