【JavaEE】Thread 类及常用方法

谁借莪１个温暖的怀抱￠ 2023-10-08 20:47 40阅读 0赞

![425ce19081877dd5e21645887af1c33a.gif][]

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

## 一、Thread 类 ##

Thread 类我们可以理解为是 java 用于管理线程的一个类，里面封装了操作系统提供的线程管理这一方面的 API （Thread 是优化后的结果）, Java 代码创建的每一个线程，可以理解为为 Thread 实例化的对象，Thread 对象用于描述线程的信息。

Java 标准库中 Thread 类可以视为是对操作系统对线程管理方面提供的 API 进行了进一步的抽象和封装.

API : Application Programing linerface

给你一个软件，你能对他干什么，基于它提供的这些功能，就可以写一些代码,然后封装在一起，方便别人使用。

![8c2b9ab1f6bc4327ae396670ada4d2b3.png][]

编辑计算机通常只有一个CPU（多核心），单核心在任意时刻只能执行一条机器指令，每个线程只有获得CPU的使用权才能执行指令。所谓多线程的并发运行，其实是指从宏观上看，各个线程轮流获得CPU的使用权，分别执行各自的任务。在运行池中，会有多个处于就绪状态的线程在等待CPU，JAVA虚拟机的一项任务就是负责线程的调度，线程调度是指按照特定机制为多个线程分配CPU的使用权。

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

### 1.1 Thread 的常见构造方法 ###

<table style=""> 
 <tbody> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">方法名</td> 
 <td style="width:369px;vertical-align:top;height:52px;">解释：</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">Thread()</td> 
 <td style="width:369px;vertical-align:top;height:52px;">创建线程对象</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">Thread( Runnable target )</td> 
 <td style="width:369px;vertical-align:top;height:52px;">使用 Runnable对象创建线程对象</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">Thread( String name )</td> 
 <td style="width:369px;vertical-align:top;height:52px;">创建线程对象，并为其命名 （方便辨认）</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">Thread(Runnable target, String name)</td> 
 <td style="width:369px;vertical-align:top;height:52px;">使用 Runnable 对象创建线程对象，并命名</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">Thread(ThreadGroup group,Runnable target)</td> 
 <td style="width:369px;vertical-align:top;height:52px;">线程可以被用来分组管理，分好的组即为线程组。</td> 
 </tr> 
 </tbody> 
</table>

## 二、 Thread 的常见属性 ##

<table style=""> 
 <tbody> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">属性</td> 
 <td style="width:369px;vertical-align:top;height:52px;">获取方法</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">ID</td> 
 <td style="width:369px;vertical-align:top;height:52px;">getId()</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">名称</td> 
 <td style="width:369px;vertical-align:top;height:52px;">getName()</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">状态</td> 
 <td style="width:369px;vertical-align:top;height:52px;">getState()</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">优先级</td> 
 <td style="width:369px;vertical-align:top;height:52px;">getPriority()</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">是否后台线程</td> 
 <td style="width:369px;vertical-align:top;height:52px;">isDaemon()</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">是否存活</td> 
 <td style="width:369px;vertical-align:top;height:52px;">isAlive()</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">是否被中断</td> 
 <td style="width:369px;vertical-align:top;height:52px;">isInterrupted()</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">返回对当前正在执行的线程对象的引用</td> 
 <td style="width:369px;vertical-align:top;height:52px;">Thread.currentThread</td> 
 </tr> 
 </tbody> 
</table>

**ID ：每个线程创建的是时候都会有一个唯一的 id,不同线程不会重复**

**名称：给每个线程起一个别名，例如：语言通话进程，文字交流进程，动态分享进程，调试进程的时候方便辨别。**

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

### 2.1 启动一个线程 ###

**java 代码创建线程的方法主要有三种**

>   
> 自定义类继承 Thread 类 ，重写父类 run 方法  
>   
> 自定义类实现Runnable 接口，重写 run 方法  
>   
> lambda 表达式，不依托类，直接指向 run 方法重写  
>

**采用 lambda表达式创建线程对象**

publicstaticvoidmain(String[] args){
           Thread t = newThread(() -> { //采用 lambda表达式创建线程对象
              System.out.println("线程 t 启动");
           });
    
           t.start(); // 启动线程,从启动开始就有两个线程流参与 CPU 的调度执行
    
           System.out.println("主线程 main");
    }

我们创建了一个线程对象，然后重写父类的 run 方法，这并不意味着线程就可以运行了。

**线程的 run 方法， 我们可以理解为主线程的 main() 方法, 我们刚开始接触编程的时候，应该都听过程序是从 main () 函数开始执行的， 此时 run 方法，就可以认为是 另一个线程的 main() 方法，多线程并发执行。run 方法中就是我们程序的另一个执行流。**

> 例如： qq 在打视频电话的时候，同时也可以接收qq 消息， 视频电话是一个线程，聊天窗口也是个线程，并发执行，互不干扰，此时我们把 qq 聊天窗口当作是 main() 方法，qq 视频通话当作是 t 线程的 run() 方法， 两个线程同属于 qq 这个进程， 当我们 启动qq 时，（一个进程中必须包含一个线程，线程是系统调度的基本单位）默认启动的是 主线程执行main()方法 , qq 一打开，聊天消息响不停，没有问题，我们不启动qq 视频电话或者是没有好友打来电话，t 线程不会被启动，这并不意味着 qq视频通话的功能不存在，需要的是手动或者是被动的启动， 那么 t 线程启动的方式就是调用我们的 t.start() 方法 ，此时 t 线程才是真正的独立的执行了，我们点击视频通话的操作就可以想象为调用了线程的start 方法启动。

**调用了 start() 方法，此时真正的在操作系统的底层创建出一个可以被调度执行的线程。**

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

### 2.2 获取当前线程的引用 currentThread() ###

publicstatic Thread.currentThread();  //返回当前线程对象的引用

![bb2f62f146974d5bbd1bf248860341d9.png][]

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

### 2.3 休眠当前线程 sleep() ###

那个线程调用该方法就会进入休眠状态（阻塞），该进程暂时不参加系统的调度。该方法会抛出InterruptedException 异常

<table style=""> 
 <tbody> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">public static void sleep(long millis) throws InterruptedException</td> 
 <td style="width:369px;vertical-align:top;height:52px;">休眠当前线程 millis毫秒</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">public static void sleep(long millis, int nanos) throwsInterruptedException</td> 
 <td style="width:369px;vertical-align:top;height:52px;">可以更高精度的休眠</td> 
 </tr> 
 </tbody> 
</table>

![e95e8face13f4c129fc12cbd147029b3.png][]

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

### 2.3 终止一个线程 ###

一个线程启动之后，进入工作状态，就会按照我们设计的程序功能去执行，没有执行完毕也不会无缘无故的结束掉线程，以上述qq 视频通话为例, 打qq 视频通话，需要我们手动启动qq 视频通话，或者好友打来视频电话，这涉及到线程的启动（调用 start () 方法）。

**如果我们想要结束掉视频通话，一般情况下有两种方法**

> 就需要手动点击挂断，通话双方都可，意思就是线程可以主动的结束（我挂断），也可以被动的结束（好友挂断），无论是是挂断电话，线程都会结束。  
>   
> 无可抗因素，例如，手机断网，当我们手机没有网络支持，通话自然而然结束，或者是网络特别卡顿，也有可能结束掉线程，再或者是手机内存不够，系统无法继续为qq 提供内存资源使其运行，会强制中止 qq 的进程，一般是直接干掉进程（进程是操作系统分配资源的基本单位，进程包含线程，多线程共享进程资源）。

**那我们java 代码在没有 （bug）的情况下如何终止进程，常见的有两种处理方法：**

> 1. 共享标记来进行沟通  
> 2. 调用 interrupt() 方法来通知线程该结束了

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

#### 2.2.1 共享标记 ####

publicclassDemo1 {
        privatestatic boolean flag = true; //共享标记
    
        publicstaticvoidmain(String[] args) throws InterruptedException {
            Thread t = newThread(() -> { //采用 lambda表达式创建线程对象
                while(flag) { // 使用共享标记可以由其他线程中止本线程
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程 t 执行");
                }
            });
    
            t.start(); // 启动线程,从启动开始就有两个线程流参与 CPU 的调度执行
    
            System.out.println("主线程 main 一秒后中止 t 线程");
            Thread.sleep(1000); //线程休眠一秒后再被CPU调度执行
            flag = false;
            System.out.println("t 线程已被中止");
        }
    }

我们定义一个boolean类型 的成员变量 flag 用于条件判断终止线程，条件判断然后 return 、抛异常都可以。

**运行结果：**

![d813fb61c83c4f44b1899aa691d8234b.png][]

运行结果有些意外，为什么当 main 线程中打印了 t 线程已被中止， 最后线程 t还打印了一个 线程 t 执行呢？ 这个问题与系统的调度有一定的关系，两个线程并发执行，可能是由一个 cpu 核心处理，那么这两个线程就在 cpu 上切换执行，完全有可能，t 线程已经完成了第五次的条件判断，还没来的及打印， cpu 就执行main 线程 修改flag = false,然后打印，此时再切换为 t 线程 ，继续打印，再从 flag 读取 boolean 值进行条件判断就不符合条件了，当然 系统怎么调度的的线程，执行顺序是无序的，会有多种可能，而且 线程可以迸发执行，共享一个控制台的话，打印是必须得分个先后得，所以这种情况是正常得。

**关于将 flag 设置为成员变量的问题：**

![6ffb675228184370af9521bd88a86853.png][]

**那能不能将 flag 定义在 main() 方法内部， 线程 t 能不能访问到 flag 呢， 答案可以的。**\*\*

![eee73513f47345478f504f2698d0a401.png][]

**但是这里报错了，原因是：lambda表达式中使用的变量应该是final或有效final**，**意思就是只能使用不发生改变的属性，如果我们 main 中只定义 flag = true; 并不对 flag 值进行修改，那么 lambda表达式中就可以访问到 flag 。**

![99d711a77f3e44afb2e84c09af918752.png][]

以上代码大致可以理解一下Java 代码线程终止线程的一种方式，写的有些简陋可能会涉及到线程安全的问题，这个篇博客在叙述。

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

#### 2.2.2 调用 interrupt() 方法 ####

> 刚刚采用的 共享标记的方法终止线程，共享标记需要我们手动的创建， interrupt() 方法是 Thread 类内置的一个方法，方法内部提供一个标志位，所以我们只需要调用该方法就可以实现终止线程的效果。

**interrupt() 方法对调用线程设置标志位**

**使用 Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 判断线程是否创建了标志位**

**Thread.currentThread() : 返回对当前正在执行的线程对象的引用，针对于该线程判断是否创建了标志位**

**Thread 内部包含了一个 boolean 类型的变量作为线程是否被中断的标记**

<table style=""> 
 <tbody> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">方法</td> 
 <td style="width:369px;vertical-align:top;height:52px;">说明</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">public void interrupt()</td> 
 <td style="width:369px;vertical-align:top;height:52px;">中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置标志位</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">public static boolean interrupted()</td> 
 <td style="width:369px;vertical-align:top;height:52px;">判断当前线程的中断标志位是否设置，调用后清除标志位</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">public boolean isInterrupted()</td> 
 <td style="width:369px;vertical-align:top;height:52px;">判断对象关联的线程的标志位是否设置，调用后不清除标志位</td> 
 </tr> 
 </tbody> 
</table>

![4bdb024e56ce463383ee395325c8a345.png][]

我们使用 isInterrupted() 方法来判断是否设置了标志位（没有是 false），用interrupt() 方法进行标志位设置 true。

publicclassDemo2 {
        publicstaticvoidmain(String[] args) throws InterruptedException {
    
            Thread t = newThread(() -> { //采用 lambda表达式创建线程对象
                while(!Thread.currentThread().isInterrupted()) { //isInterrupted() 判断是否设置了标志位
                    //!Thread.interrupted();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程 t 执行");
                }
            });
    
            t.start(); // 启动线程,从启动开始就有两个线程流参与 CPU 的调度执行
    
            System.out.println("主线程 main 3秒后中止 t 线程");
            Thread.sleep(3000); //线程休眠一秒后再被CPU调度执行
            
            t.interrupt(); // 设置把标志位,并将标志设置为true;
        }
    }

**Thread 接收到的是否有标志位通知有两种情况：**

如果线程是因为 调用了sleep、join 等方法的原因阻塞（只要是阻塞，阻塞可以看作线程暂时不参加 CPU 的调度了），然后 t. interrupt() 方法设置标志，那么会通过抛出 InterruptedException 异常的形式通知，将线程唤醒，此处博主使用 sleep() 使得 t 线程休眠(阻塞一秒)，主线程（main）调用方法设置标志后线程被强制唤醒，sleep() 会将标志位置为空 （标志位置为 false），意思就是相当于没设置标志，isInterrupted() 方法检查没有标志位，返回 false, 然后方法前面 ！（非），结果返回 true, 线程不会终止。  
当抛出 InterruptedException 异常的时候, 要不要结束线程取决于 catch 中代码的写法.，可以选择忽略这个异常（博主这里直接将异常抛出,所以标志位就被清空了）, 也可跳出循环结束线程（break）。

**没有阻塞等特殊情况，有两种方式判断是否存在标志位：**

> 1）Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志 （清除后返回false）\*  
> 2）Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志  
>

那么博主这段代码明显是第一种方式，设置一个标志位也是一波三折，看看运行结果：

![64dbd73eec4741bf9d9cb3df9863e262.png][]

> 抛出异常后 t 线程继续执行，说明抛出异常后，标志位被清除了，t 线程是循环一次sleep 阻塞一秒嘛，所以打印了两个结果，第三秒，主线程给 t 线程设置标志位(本意结束 t 线程)，结果直接唤醒 阻塞中的 t 线程，从sleep 状态被唤醒后，sleep 将 isInterrupted() 的标志位清空，导致循环无法结束。

> 阻塞状态被设置标志位唤醒，将标志位清空的目的也是为了线程对何时结束有一个灵活的掌控， 如果上述状态我们对 sleep 进行异常处理 carch 里面添加break； 或者是 return； 都是可以的比较灵活。

> 调用 interrupt() 方法终止线程本质上还是设置标志位，不是说直接将线程干掉，而是程序通过标志位的信息可以进行终止线程的操作。

两个人打qq 视频电话，你不挂断，我也不挂断，那就一直死循环，挂断就相当于对这个循环按 break; 循环结束，如果该线程没有什么其他程序要执行的话启动周期也结束了。

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

### 2.3 join() 等待一个线程 ###

等待一个线程，预设一个场景：

![fd3a79c86d254aff818d7c1bde593308.png][]

在只有一个厕所的情况下，李四只有等待张三（线程）执行完毕后才能上厕所（被调度），期间李四只能是耐心等待，也不能干其他的事。

同一进程下，多线程的调度是并发执行（CPU 来回切换执行线程），操作系统对线程的调度是无序的，每个线程被执行的时间也是未知的，无法判断线程之间的执行的先后顺序，那么使用 join 方法就可以指定那个线程等待那个线程执行完毕。

publicstaticvoidmain(String[] args) throws InterruptedException {
 Thread t = newThread( () -> {
 for (int i = 0; i < 5; i++) {
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("线程 t 执行");
 }
 });
 
 t.start(); //启动线程 t
 
 for (int i = 0; i < 5; i++) {
 Thread.sleep(1000);
 System.out.println("主线程 main 执行");
 }
 }

![7ae6ee53a3876e43cb317a523aa14885.gif][]

![b709c29638af404d908abedf19287151.png][]

运行打印结果有时候 main 线程前，有时候 t 线程在前，这也说体现了线程的调度是无序的这个概念，添加 sleep函数的目的就是使得线程休眠一秒再执行，因为CPU 的执行速度很快，数据量小无法观察到这种并发调度的状态。

假设现在我们想让 main 主线程等待 t 线程执行完毕后再执行 自身的操作，就可以使用 join 方法。

![4577affd9eab45da9cc11eb81b80ca0a.png][]

很明显，使用 join 方法后线程的调度是有序的，但是此时 两个线程不再是并发执行，而是串行执行了， 在main 线程中 调用了 t. join 方法，意思就是 让main 线程等待 线程 t 执行完毕后，再往下执行， 谁调用，谁等待，等待的一方，直接进入 Blocked 阻塞状态，阻塞可以看作线程暂时不参加 CPU 的调度执行。

main 线程调用 t.join 的时候，如果 t 正在运行，此时 main 线程直接进入阻塞态，直到 t 线程执行完毕（run 方法执行完了），main 线程才会解除阻塞，继续参与系统调度，CPU 执行。

> 如果 t 线程一直在执行，那么 main 线程就会一直处于阻塞状态，这谁能忍，所以 join 还有另一个重载后的方法，可以在调用 join 时提供一个最大等待时间的参数，超出等待时间 main 线程也可以解除阻塞态。

<table style=""> 
 <tbody> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">方法</td> 
 <td style="width:369px;vertical-align:top;height:52px;">说明</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">public void join()</td> 
 <td style="width:369px;vertical-align:top;height:52px;">等待线程结束</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">public void join(long millis)</td> 
 <td style="width:369px;vertical-align:top;height:52px;">等待线程结束，最多等 millis 毫秒</td> 
 </tr> 
 <tr> 
 <td style="width:369px;vertical-align:top;height:52px;">public void join(long millis, int nanos)</td> 
 <td style="width:369px;vertical-align:top;height:52px;">同理，更高精度</td> 
 </tr> 
 </tbody> 
</table>

![6ab7e2d362e84287b29096ac21695d98.png][]

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

至此，Java Thread 类及常用方法属性 博主已经分享完了，希望对大家有所帮助，如有不妥之处欢迎批评指正。

![107876d4ffe84bc4a24fd235a49e8b2f.jpeg][]

本期收录于博主的专栏——JavaEE，适用于编程初学者，感兴趣的朋友们可以订阅，查看其它“JavaEE基础知识”。

**下期预告：线程的状态及线程安全相关问题**

感谢每一个观看本篇文章的朋友，更多精彩敬请期待：保护小周ღ **\*★,°\*:.☆(￣▽￣)/$:\*.°★\* ‘**

[425ce19081877dd5e21645887af1c33a.gif]: https://img-blog.csdnimg.cn/img_convert/425ce19081877dd5e21645887af1c33a.gif
[8c2b9ab1f6bc4327ae396670ada4d2b3.png]: https://img-blog.csdnimg.cn/img_convert/8c2b9ab1f6bc4327ae396670ada4d2b3.png
[bb2f62f146974d5bbd1bf248860341d9.png]: https://img-blog.csdnimg.cn/img_convert/bb2f62f146974d5bbd1bf248860341d9.png
[e95e8face13f4c129fc12cbd147029b3.png]: https://img-blog.csdnimg.cn/img_convert/e95e8face13f4c129fc12cbd147029b3.png
[d813fb61c83c4f44b1899aa691d8234b.png]: https://img-blog.csdnimg.cn/img_convert/d813fb61c83c4f44b1899aa691d8234b.png
[6ffb675228184370af9521bd88a86853.png]: https://img-blog.csdnimg.cn/img_convert/6ffb675228184370af9521bd88a86853.png
[eee73513f47345478f504f2698d0a401.png]: https://img-blog.csdnimg.cn/img_convert/eee73513f47345478f504f2698d0a401.png
[99d711a77f3e44afb2e84c09af918752.png]: https://img-blog.csdnimg.cn/img_convert/99d711a77f3e44afb2e84c09af918752.png
[4bdb024e56ce463383ee395325c8a345.png]: https://img-blog.csdnimg.cn/img_convert/4bdb024e56ce463383ee395325c8a345.png
[64dbd73eec4741bf9d9cb3df9863e262.png]: https://img-blog.csdnimg.cn/img_convert/64dbd73eec4741bf9d9cb3df9863e262.png
[fd3a79c86d254aff818d7c1bde593308.png]: https://img-blog.csdnimg.cn/img_convert/fd3a79c86d254aff818d7c1bde593308.png
[7ae6ee53a3876e43cb317a523aa14885.gif]: https://img-blog.csdnimg.cn/img_convert/7ae6ee53a3876e43cb317a523aa14885.gif
[b709c29638af404d908abedf19287151.png]: https://img-blog.csdnimg.cn/img_convert/b709c29638af404d908abedf19287151.png
[4577affd9eab45da9cc11eb81b80ca0a.png]: https://img-blog.csdnimg.cn/img_convert/4577affd9eab45da9cc11eb81b80ca0a.png
[6ab7e2d362e84287b29096ac21695d98.png]: https://img-blog.csdnimg.cn/img_convert/6ab7e2d362e84287b29096ac21695d98.png
[107876d4ffe84bc4a24fd235a49e8b2f.jpeg]: https://img-blog.csdnimg.cn/img_convert/107876d4ffe84bc4a24fd235a49e8b2f.jpeg