多线程Thread（初阶二：Thread类及常⻅⽅法）

本是古典何须时尚 2024-02-18 13:33 27阅读 0赞

**目录**

一、Thread 的常⻅构造⽅法

继承Thread代码：

实现Runnable接口代码:

二、Thread 的⼏个常⻅属性

1、id：

2、获取线程的名字。

3、进程的状态：

4、在java中设置的优先级，

5、是否后台线程，

6、是否存活，

7、是否中断，

8、等待线程（结束），

9、获取线程的引用，currentThread()

--------------------

## **一、Thread 的常⻅构造⽅法** ##

![cd5e387ebe9a4dda9da604d30980dcbf.png][]

最后一个线程组的概念是java的概念，和系统中的线程组不一样，不是同一个东西。

第一个和第二个构造方法在初阶一有介绍，

链接：[多线程Thread（初阶一：认识线程）-CSDN博客][Thread_-CSDN]

第三是创建一个线程，并且可以给这个线程命名，并不是它默认的Thread-0 / 1 / 2.....，第四个也是可以给线程对象命名，不过是使用接口的方法。

### **继承Thread代码：** ###

>     class MyThread extends Thread {
>         @Override
>         public void run() {
>             System.out.println("hello thread1");
>         }
>         String name;
>         public MyThread(String name) {
>             super(name);
>             this.name = name;
>         }
>     }
>     public class ThreadDemo1 {
>         public static void main(String[] args) {
>             Thread t1 = new MyThread("这是我的线程");
>             t1.start();
>             Thread t2 = new Thread("这是我的线程"){
>                 @Override
>                 public void run() {
>                     System.out.println("hello thread2");
>                 }
>             };
>             t2.start();
>         }
>     }
> 
> 执行效果：
> 
> ![ac710ee329a64e96be80047f1073ed09.png][]
> 
> 两个线程：
> 
> ![df998db2cdf64275a89de21adf3fe549.png][]
> 
> 上面两种的两种创建线程方式都可以。

### **实现Runnable接口代码:** ###

>     class MyThread2 extends Thread {
>         String name;
>         public MyThread2(String name) {
>             super(name);
>             this.name = name;
>         }
>         @Override
>         public void run() {
>             System.out.println("hello thread1");
>         }
>     }
>     public class TestDemo2 {
>         public static void main(String[] args) {
>             Thread t1 = new MyThread2("这是我的线程1");
>             t1.start();
>             Thread t2 = new Thread("这是我的进程2") {
>                 @Override
>                 public void run() {
>                     System.out.println("hello thread2");
>                 }
>             };
>             t2.start();
>         }
>     }
> 
> 执行效果：
> 
> ![4e73b376127a4c3c983b1f4e0d036508.png][]
> 
> 两个线程：
> 
> ![d8423e1f5cc249e88ecef9b7c0996c86.png][]

**注意：**我们创建的线程如果不起名字，默认是Thread-0 1 2 3....，给不同线程起不同名字，对于线程的执行，没啥影响，主要是为了方便调试；线程之间的名字是可以重复的，在同一个工作中，需要多个线程完成，都可以起一样的名字；但是名字也不要乱起，最后要有一定的描述性。

##  ##

--------------------

## 二、Thread 的⼏个常⻅属性 ##

![ab9dfc6cc36d471cad54b7723e6fc0e8.png][]

### **1、id**： ###

jvm自动分配的身份标识，会保证唯一性。

### **2、获取线程的名字。** ###

### **3、进程的状态**： ###

就绪状态、阻塞状态；线程也有状态，Java中对线程的状态进行了进一步的区分（比系统原生的状态更丰富一些）。

### **4、在java中设置的优先级**， ###

效果不是很明显，因为系统是随机调度的（对内核的调度器调度过程会产生一些影响）。

### **5、是否后台线程**， ###

也称为是否守护线程（比较抽象），所以记住和理解是否后台线程会轻松一些，与此相反，也有前台线程（和Android上的前台app，后台app完全不同）。

**后台线程和前台线程的区别**：前台线程的运行，会阻止进程结束

后台线程的运行，不会阻止进程结束

> 我们创建的线程，默认是前台进程。
> 
> 如下代码：
> 
>     public class TestDemo3 {
>         public static void main(String[] args) {
>             Thread t = new Thread() {
>                 @Override
>                 public void run() {
>                     while (true) {
>                         System.out.println("hello thread");
>                         try {
>                             Thread.sleep(1000);
>                         } catch (InterruptedException e) {
>                             throw new RuntimeException(e);
>                         }
>                     }
>                 }
>             };
>             t.start();
>         }
>     }
> 
> 执行效果：会不停的输出打印hello thread
> 
> ![b7cb703576e64a3ba8c1faec12a0be1c.png][]
> 
> 那我们试着把这个线程设置为后台线程试试（默认为前台），代码：
> 
>     public class TestDemo3 {
>         public static void main(String[] args) {
>             Thread t = new Thread() {
>                 @Override
>                 public void run() {
>                     while (true) {
>                         System.out.println("hello thread");
>                         try {
>                             Thread.sleep(1000);
>                         } catch (InterruptedException e) {
>                             throw new RuntimeException(e);
>                         }
>                     }
>                 }
>             };
>             //在start之前，设置线程为后台线程（不能在start之后设置）
>             t.setDaemon(true);
>             t.start();
>         }
>     }
> 
> 执行效果：
> 
> ![f0557c0ea6b5457a9c1bb0c640814f54.png][]
> 
> 根本就没有打印hello thread，进程就结束了，因为是后台进程，不会阻止进程的结束。
> 
> 设为true是后台，后台，可以理解为背后，不出面的人，你感知不到；后台不会阻止进程结束。
> 
> 不设为true是前台，前台，可以理解为明面上的人，你能感知到；前台会阻止进程结束。

### **6、是否存活，** ###

isAlive( )表示内核中的线程（PCB）是否还存在。java代码中定义的线程对象（Thread）实现，虽然是表示一个线程，但这个对象本身的生命周期，和内核中的PCB生命周期 ，是不完全一样的。

> isAlive的测试，代码：
> 
>     public class TestDemo4 {
>         public static void main(String[] args) throws InterruptedException {
>             Thread t = new Thread(() -> {
>                 try {
>                     Thread.sleep(1000);
>                 } catch (InterruptedException e) {
>                     throw new RuntimeException(e);
>                 }
>             });
>             System.out.println("start之前：" + t.isAlive());
>             t.start();
>             System.out.println("start之后" + t.isAlive());
>             Thread.sleep(2000);
>             System.out.println("t结束之后" + t.isAlive());
>         }
>     }
> 
> **执行效果：**
> 
> ![f9cdefe3677e4ad8b863148b0ab0cb2c.png][]
> 
> **解释：**启动线程之前，也就是start之前，t这个实例线程是还没开始的，所以isAlive返回的是false，start后就查看这个线程存不存在，因为线程也刚启动，所以isAlive返回的是true，休眠两秒之后，t线程已经跑完了，所以isAlive返回的也是false。

### **7、是否中断**， ###

也是终止的意思。

> 下面写一个代码，用boolean类型的变量来控制while循环，也起到终止线程的作用。
> 
>     public class ThreadDemo1 {
>         private static boolean isQuit = false;
>         public static void main(String[] args) throws InterruptedException {
>             Thread t = new Thread(() -> {
>                 while (!isQuit) {
>                     System.out.println("我是一个线程，正在工作");
>                     try {
>                         Thread.sleep(1000);
>                     } catch (InterruptedException e) {
>                         throw new RuntimeException(e);
>                     }
>                 }
>                 System.out.println("线程工作完毕");
>             });
>             t.start();
>             Thread.sleep(3000);
>     
>             System.out.println("让线程结束");
>             isQuit = true;
>         }
>     }
> 
> **注意：**这里的isQuit变量放在类中，不放在方法里作为局部变量的原因是涉及到了**变量捕获，**如果放在main方法里，**是局部变量，就必须要加 final 修饰将其变成常量**，为什么呢？这时因为main线程和我们创建的线程的栈帧生命周期不同，如果main线程先结束了，我们创建的线程要获取这个变量，但是我们main线程的栈帧生命周期已经结束了，我们拿不到这个变量，java这里的做法就比较暴力，直接把这个变量变成常量，要么这个变量就是全局变量，以至于不会发生上面的情况。
> 
> **执行效果：**
> 
> ![8020ebbdb4214c7887d60114a241d8f7.png][]
> 
> 这时，我们也可以使用jdk里自带的方法：**isInterrupted( )**
> 
> 代码如下：
> 
>     public class ThreadDemo2 {
>         public static void main(String[] args) throws InterruptedException {
>             Thread t = new Thread(() -> {
>                 while (!Thread.currentThread().isInterrupted()) {
>                     System.out.println("我是一个线程，正在工作");
>                     try {
>                         Thread.sleep(1000);
>                     } catch (InterruptedException e) {
>                         e.printStackTrace();
>                     }
>                 }
>                 System.out.println("线程执行完毕");
>             });
>     
>             t.start();
>     
>             Thread.sleep(3000);
>             System.out.println("让线程结束");
>             t.interrupt();
>         }
>     }
> 
> 执行效果：![fa89ea945ff24d3fa796457171cdb71a.png][]
> 
> 这个线程并不会结束，会继续执行。
> 
> **解释：**可以看到这里抛出了个异常，而这个异常是**InterruptedException** 异常
> 
> 如果没有sleep，interrupt是可以让线程顺利结束的，但是有了sleep就会引起变数。
> 
> 这说明，sleep这出现问题了，为什么呢？原因是这个线程还在执行，main线程休眠3秒后，终止了这个线程，但sleep还没休眠够1秒，这里就会提前唤醒。
> 
> 这里，提前唤醒，会做两件事：
> 
> 1、抛出 **InterruptedException** （紧接着就会被catch获取到）。
> 
> 2、清除 Thread 对象的 isInterrupt 标志位。（sleep清空标志位，是为了给程序猿更多的“可操作性空间”）。
> 
> 所以，interrupt已经把标志位设置为true了，sleep被提前唤醒，清除了isInterrupt标志位后，就又把标志位设回了false，这个while循环还是能进去的，所以线程还在继续执行。
> 
> 此时，程序猿就可以在catch语句中加入一些代码，来做一些处理：
> 
> 1、让线程立即结束。（加上break）
> 
> 2、让线程不结束，继续执行。（不加break）
> 
> 3、让线程执行一些逻辑后，再结束。（写一些其他代码，再加break）
> 
> 对于一个服务器程序来说，稳定性很重要，这些所谓的“问题”，在java中就会以异常的形式体现出来，可以通过catch语句，对这些异常进行处理。主要的几种处理方式：
> 
> 1、尝试自动恢复
> 
> 2、记录日志
> 
> 3、发出警报

### **8、等待线程（结束），** ###

**join（ ）。**我们知道，多线程的执行顺序是不同的（随机调度，抢占式执行），有不可预期性，虽然线程的调度是无序的，但是我们可以调用一些api，来影响带线程的执行顺序，join就是一种方式，影响 线程结束 的先后顺序。比如：t2 线程等待 t1，这时，一定是 t1先结束，t2 后结束。这里的join就会使 t2 线程阻塞。

> **代码：**
> 
>     public class ThreadDemo3 {
>         public static void main(String[] args) {
>             Thread t = new Thread(() -> {
>                for (int i = 0; i < 5; i++) {
>                    System.out.println("我是一个线程，正在工作");
>                    try {
>                        Thread.sleep(1000);
>                    } catch (InterruptedException e) {
>                        throw new RuntimeException(e);
>                    }
>                }
>                 System.out.println("线程结束");
>             });
>             
>             t.start();
>             //t.join();
>             
>             System.out.println("这时一个主线程，在t线程结束后再执行");
>         }
>     }
> 
> 我们想让t线程执行完后再执行主线程，如果不写join方法。因为多线程的调度是随机性的，执行效果如下：
> 
> ![640d361b19ba4f9f99198b2b57714043.png][]
> 
> 执行效果和我们预期的不一样，加上join方法后，
> 
> **代码：**
> 
>     public class ThreadDemo3 {
>         public static void main(String[] args) throws InterruptedException {
>             Thread t = new Thread(() -> {
>                for (int i = 0; i < 5; i++) {
>                    System.out.println("我是一个线程，正在工作");
>                    try {
>                        Thread.sleep(1000);
>                    } catch (InterruptedException e) {
>                        throw new RuntimeException(e);
>                    }
>                }
>                 System.out.println("线程结束");
>             });
>             t.start();
>             t.join();
>             System.out.println("这时一个主线程，在t线程结束后再执行");
>         }
>     }
> 
> **执行效果：**
> 
> ![f019807042c04f2e84c197f2d938d469.png][]
> 
> 结果和我们想要预期效果相同。这里的join的意思是：**让 t 线程执行完，再执行本线程。**
> 
> 这里是让main线程主动放弃去调度器调度，t 线程执行完后，main线程才执行，这也代表哪个线程调用join，哪个线程就是阻塞等待。这里就有了先后顺序。
> 
> 注意：这里的先后顺序和优先级不同，优先级是系统调度器，在内核中完成的工作，即使优先级有差异，但是每个线程的执行顺序还是随机的（控制不了）。
> 
> 等待线程结束还有两个重载方法，里面放的是要等待的时间,如图：  
> ![ebc580c23da2429c8b354dd97b8b6753.png][]
> 
> 如果join不加参数，就是死等，第一个加参数的就是：等待多少毫秒，第二个加参数：数值精确到纳秒，不过很少用，因为计算机精确不到这么小。加参数是带有时间的等。
> 
> 注意，有时候不想等，我们也可以不等，例如加 interrupt，可以终止这个等待，我们也可以在idea看到join的实现，是throws了 InterruptedException的。
> 
> ![cd3e1b2dc2eb4ba08f718a9e7f87ce67.png][]

### 9、获取线程的引用，currentThread() ###

> 我们对于一个类继承Thread是可以通过this拿到线程的实例的，
> 
> 代码如下：
> 
>     class MyThread extends Thread {
>         @Override
>         public void run() {
>             System.out.println("id:"+ this.getId() + " name:" + this.getName());
>         }
>     }
>     public class ThreadDemo1 {
>         public static void main(String[] args) {
>             Thread t = new MyThread();
>             t.start();
>         }
>     }
> 
> 效果如下：
> 
> ![d1922109b5d74736a2896855b109993a.png][]
> 
> 但是，如果是接口或者我们使用匿名内部类 / lambda表达式，就不能获取到Thread的引用了，这时，Thread已经给我们提供了方法获取引用了：Thread.currentThread()。如下展示：
> 
> 代码：
> 
>     public class ThreadDemo2 {
>         public static void main(String[] args) {
>             Thread t1 = new Thread(() -> {
>                 Thread t = Thread.currentThread();
>                 System.out.println(t.getId());
>             });
>             Thread t2 = new Thread(() -> {
>                 Thread t = Thread.currentThread();
>                 System.out.println(t.getName());
>             });
>             t1.start();
>             t2.start();
>         }
>     }
> 
> 效果如下：
> 
> ![743259539cae49eaa074cbfa6e2eebab.png][]

--------------------

### 都看到这了，点个赞再走吧，谢谢谢谢谢！！！ ###

[cd5e387ebe9a4dda9da604d30980dcbf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/d5a61d1a7d17458c8490b0a38bc1a730.png
[Thread_-CSDN]: https://blog.csdn.net/cool_tao6/article/details/134483484?spm=1001.2014.3001.5502
[ac710ee329a64e96be80047f1073ed09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/45514030589e4de99a46a7919bc5b34b.png
[df998db2cdf64275a89de21adf3fe549.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/fb20ce1020554419bf9021e388ae365e.png
[4e73b376127a4c3c983b1f4e0d036508.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/c236fe04c84c4a048b1e7dd1cad98f12.png
[d8423e1f5cc249e88ecef9b7c0996c86.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/b758115b89364909ba9f1ebcfc35ecd9.png
[ab9dfc6cc36d471cad54b7723e6fc0e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/eb46b5d12b0b453db265a6dc00c20371.png
[b7cb703576e64a3ba8c1faec12a0be1c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f071e55991af44108dd6fff4939c7523.png
[f0557c0ea6b5457a9c1bb0c640814f54.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/4ba5d2ba465446b8b33a4ca882d14c85.png
[f9cdefe3677e4ad8b863148b0ab0cb2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/be74902b543d426d81620396e9d03af8.png
[8020ebbdb4214c7887d60114a241d8f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/75d0792e29c64c9db8939823937612a4.png
[fa89ea945ff24d3fa796457171cdb71a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/55bc4a55603042f49dd60da404fb706a.png
[640d361b19ba4f9f99198b2b57714043.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/cd9ed8f78635412fb3f81548c261730f.png
[f019807042c04f2e84c197f2d938d469.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/e64585116f7d4de88697ba0e6a7167d6.png
[ebc580c23da2429c8b354dd97b8b6753.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/edf0dc49dc584b4abcb345439c0f5a62.png
[cd3e1b2dc2eb4ba08f718a9e7f87ce67.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/ad3401cc8cdf46149eaaee01ead9e68b.png
[d1922109b5d74736a2896855b109993a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/68ad675138da4445a48e06768912bde9.png
[743259539cae49eaa074cbfa6e2eebab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/2e8080b7e04640e59455b2b5e56e1565.png