Subprocesos múltiples - Programación concurrente (4) - Introducción al estado de los subprocesos y algunos métodos comunes

El estado del hilo se puede obtener a través del método Thread.getState (hay 6 estados del hilo)

NUEVO (nuevo) nuevo: aún no iniciado

RUNNABLE (estado ejecutable) ejecutable: se está ejecutando en la JVM; o está esperando otros recursos del sistema operativo (como los procesadores)

//有些编程语言会把RUNNABLE分成2种情况
//1.running
//2.ready
//以上2种在Java中都属于RUNNABLE

BLOQUEADO (estado bloqueado) bloqueado: esperando el bloqueo del monitor (bloqueo interno)

ESPERANDO (estado de espera) esperando: esperando otro subproceso ,
llamar a los siguientes métodos estará en un estado de espera
Object.wait
sin un valor de tiempo de espera Thread.join
LockSupport.park sin un valor de tiempo de espera
//se presentará en detalle más adelante

TIMED_WAITING (estado de espera temporizado) timed_waiting llama a los siguientes
métodos para estar en un estado de espera temporizado.
Thread.sleep
tiene un valor de tiempo de espera. Object.wait
tiene un valor de tiempo de espera
.

TERMINADO (estado de terminación): se han ejecutado
algunas instancias :

public class Main {
	public static void main(String[] a) {
		Thread dangqian = Thread.currentThread();//获取主线程
		System.out.println(dangqian.getState());//输出RUNNABLE
		//表示主线程正处于RUNNABLE状态
		
		Thread tj = new Thread();//新建1个线程
		System.out.println(tj.getState());//输出NEW
		
		Thread tj1 = new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("ACM");
			}
		});
		tj1.start();
		//启动执行完run方法后线程终止 此时处于TERMINATED状态
	}
}

introducción a la interrupción del sueño

Puede suspender el subproceso actual a través del método Thread.sleep y entrar en el estado ESPERANDO
Durante el período de suspensión, si se llama al método de interrupción del objeto del subproceso para interrumpir el subproceso, se lanzará una java.lang.InterruptedException.

El ejemplo (nota) de introducción es más explícito: 

public class Main {
	public static void main(String[] a) {
		Thread tj = new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("1");
				try {
					Thread.sleep(3000);//sleep是静态方法，所以通过类名来调用；让线程睡3s
				}catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("2");
			}
		});
		tj.start();
		//因为是多线程，在执行tj线程时，主线程依然往下走
		try {
			Thread.sleep(1000);//让主线程睡1s
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("3");
		//由于tj线程睡得较久，所以先打印3，再打印2
		tj.interrupt();//中断此线程，但实际上只是给线程设置一个中断标志，线程仍会执行；在这里用于触发异常
	}
}

输出：
1
3
2

join isAlive Introduzca
el método A.join: después de que el subproceso A termine de ejecutarse, el subproceso actual continuará ejecutando la tarea. Puede pasar parámetros para especificar el tiempo de espera más largo
Método A.isAlive: verifique si el hilo A todavía está vivo

Ejemplo:

public class Main {
	public static void main(String[] a) {
		Thread tj = new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("1");
				try {
					Thread.sleep(3000);//sleep是静态方法，所以通过类名来调用；让线程睡3s
				}catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("2");
			}
		});
		tj.start();
		System.out.println(tj.isAlive());//此时3s未过，tj线程仍在执行；所以输出true
		try {
			tj.join();//等tj线程执行完毕再往下执行
			//tj.join(1000); 等待tj线程1s再往下执行
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("3");
	    System.out.println(tj.getState());
	    System.out.println(tj.isAlive());//tj线程已执行完毕；所以输出false
	}
}

输出：
true
1
2
3
TERMINATED
false