contenido
Primero, varias propiedades de la clase Thread
⭐① El ID es el identificador único del subproceso, y no se repetirán diferentes subprocesos.
② Varias herramientas de depuración utilizan el nombre
. ③ El estado indica la situación actual del subproceso. Explicaremos más adelante.
⭐④ Alto En teoría, es más fácil programar los subprocesos prioritarios
⑤Acerca de los subprocesos daemon (subprocesos en segundo plano), debe recordar una cosa: JVM dejará de ejecutarse después de que finalicen todos los subprocesos que no sean de fondo de un proceso.
⑥Si está vivo , es decir, un entendimiento simple, si el método de ejecución ha terminado de ejecutarse o no.
El problema de interrupción del hilo
propiedad: estado - getState()
Thread thread = new Thread(() ->{
System.out.println("当前线程的状态1" + Thread.currentThread().getState());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println("当前线程的状态2" + thread.getState());
thread.start();
Atributos: ID y Nombre – getId() y getName()
/**
* 线程属性
* ID和名称 ；ID一定是不同的，是动态分配的
* 线程名称手动设置
*/
public class ThreadDemo11 {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
Thread t = Thread.currentThread();
System.out.println("线程ID" + t.getId());
System.out.println("线程名称" + t.getName() );
}
});
thread.start();
}
}
atributo: prioridad - getPriority()
/**
* 获取优先级
*/
public class ThreadByPriority {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
// 得到当前线程，并打印线程的优先级
Thread thread1 = Thread.currentThread();
System.out.println("线程优先级1：" + thread1.getPriority());
}
});
System.out.println("线程优先级2：" + thread.getPriority());
thread.start();
}
}
Atributo: ya sea para daemon thread-isDaemon()
//在主线程创建子线程
Thread t = new Thread(()->{
Thread t1 = Thread.currentThread();
System.out.println(t1.getName() + "是否守护线程" + t1.isDaemon());
// 创建子线程
Thread tt1 = new Thread(() -> {
Thread cThread2 = Thread.currentThread();
System.out.println(cThread2.getName() + "——是否守护线程：" + cThread2.isDaemon());
}, "子线程的子线程1");
tt1.start();
},"子线程1");
Atributo: vivo o no - isAlive()
/**
* 线程是否存活 isAlive() -while循环
*/
public class DaemonThreadAlive {
public static void main(String[] args) {
Thread t = new Thread(() ->{
for(int i=0;i < 10;i++){
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("执行完了");
});
t.start();
//判断是否存活
while(t.isAlive()){
}
System.out.println("确认执行完了");
}
}
En segundo lugar, inicie un hilo - start()
Se puede considerar que el objeto hilo llamó a Li Si y Wang Wu.
Y llamar al método start() es gritar: "¡Adelante!", y el hilo realmente puede ejecutarse de forma independiente.
Thread thread = new Thread(()->{
//业务代码
Thread thread3 = Thread.currentThread();
System.out.println("名称" + thread3.getName());
});
//启动线程
thread.start();
En tercer lugar, el método de interrupción del hilo.
Actualmente hay dos métodos comunes:
1. Comuníquese a través del marcado compartido
//declara un identificador personalizado
private volatile static boolean flag = false;
/**
* 自定义标识符终止线程
*/
public class InterruptThread1 {
//声明一个自定义标识符
private volatile static boolean flag = false;
public static void main(String[] args) {
Thread thread = new Thread(() -> {
while(!flag){
System.out.println("正在转账");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("差点误了大事");
});
thread.start();
System.out.println("执行结束");
}
}
Si la bandera está borrada
Si se borra la bandera es similar a un interruptor.
Thread.isInterrupted() es equivalente a presionar el interruptor, y el interruptor aparece automáticamente. Esto se llama "borrar la bandera"
Thread.currentThread().isInterrupted() es equivalente a presionando el interruptor Después de eso, el interruptor no rebotará, esto se llama **"no borrar la bandera".**
2. Llame al método interrupt() para notificar
// Terminar el subproceso
thread.interrupt();
System.out.println("Terminar transacción");
thread.start();
Thread.sleep(1000);
//终止线程
thread.interrupt();
System.out.println("终止交易");
System.out.println("终止标志位3" + Thread.currentThread().isInterrupted());
3. La diferencia entre interrumpido e interrumpido
①interrumpido es un método estático, un método global que pueden usar todos los programas, isInterrupted es un método de una instancia
②interrumpido restablecerá el identificador después del uso isInterrupted no se restablecerá
Por favor vea el análisis detallado
Enlace : https://blog.csdn.net/qq_55660421/article/details/123662613 .
En cuarto lugar, espere a que se una a un subproceso ()
A veces, necesitamos esperar a que un subproceso complete su trabajo antes de poder continuar con nuestro próximo trabajo. Por ejemplo, Li Si solo decide si trabajar después de que el trabajo de Zhang San sea exitoso. En este momento, necesitamos un método para esperar explícitamente el final del hilo.
public class ThreadByJoin {
public static void main(String[] args) throws InterruptedException{
Thread t1 = new Thread(() -> {
// 1.张三开始上班
System.out.println("1.张三开始上班");
// 2.张三正在上班
try {
Thread.sleep(10 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 3.张三下班
System.out.println("3.张三下班");
});
// 启动程序
t1.start();
// while (t1.isAlive()) {
// }
// 等待线程 t1 执行完之后，再执行后面的代码
t1.join();
Thread t2 = new Thread(() -> {
// 1.李四开始上班
System.out.println("1.李四开始上班");
// 2.李四正在上班
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 3.李四下班
System.out.println("3.李四下班");
});
t2.start();
}
}
Cinco, dormir el hilo actual
Hay dos implementaciones de subprocesos durmientes:
Usa dormir para dormir
También estamos familiarizados con un conjunto de métodos. Una cosa para recordar es que debido a que la programación de subprocesos es incontrolable, este método solo puede garantizar que el tiempo de suspensión real sea mayor o igual que el tiempo de suspensión establecido por los parámetros.
/**
* 休眠线程
*/
public class ThreadSleep {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(10*1000);
} catch (InterruptedException e) {
System.out.println("我接收到了中止执行的通知");
// e.printStackTrace();
}
}
});
t.start();
//休眠线程
Thread.sleep(1000);
System.out.println("终止子线程 thread");
t.interrupt();//终止线程
}
}
Dormir con TimeUnit
import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;
/**
* 休眠线程
*/
public class ThreadTimeUtil {
public static void main(String[] args) throws InterruptedException {
System.out.println("主线程开始执行了：" + LocalDateTime.now());
TimeUnit.SECONDS.sleep(3); // 休眠 3s
System.out.println("主线程又开始执行了：" + LocalDateTime.now());
}
}
Seis, obtener una referencia al hilo actual
public class ThreadDemo {
public static void main(String[] args) {
Thread thread = Thread.currentThread();
System.out.println(thread.getName());
}
}