Thread类及常见方法

矫情吗；* 2024-02-17 10:15 3阅读 0赞

## 基本概念 ##

Thread类是JVM用来管理线程的一个类,换句话说,每个线程都有一个唯一的Thread对象与之关联.

> 用上一篇中的例子来看,每个执行流,也需要有一个对象来描述,而T**hread类的对象就是用来描述一个线程的执行流的**,JVM也会将这些Thread对象组织起来,用于线程调度,线程管理.

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

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td><strong>方法</strong></td> 
   <td><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td>Thread()</td> 
   <td>创建线程对象</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target)</td> 
   <td>使用Runnable对象创建线程对象</td> 
  </tr> 
  <tr> 
   <td>Thread(String name)</td> 
   <td>创建线程对象,并命名</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target, String name)</td> 
   <td>使用Runnable对象创建线程对象,并命名</td> 
  </tr> 
  <tr> 
   <td>[了解]Thread(ThreadGroup group, Runnable target)</td> 
   <td> <p>线程可以用来分组管理(了解即可)</p> </td> 
  </tr> 
 </tbody> 
</table>

> 注:一般自己创建的线程(没有命名),默认为Thread-0,1,2,3...
> 
> 这个是不太好区分的,推荐利用上面命名的构造方法

Thread t1 = new Thread();
    Thread t2 = new Thread(new MyRunnable());
    Thread t3 = new Thread("这是我的名字");
    Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

## Thread的几个常见属性 ##

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td><strong>属性</strong></td> 
   <td><strong>获取方法</strong></td> 
  </tr> 
  <tr> 
   <td>ID</td> 
   <td>getId()</td> 
  </tr> 
  <tr> 
   <td>名称</td> 
   <td>getName()</td> 
  </tr> 
  <tr> 
   <td>状态</td> 
   <td> <p>getState()</p> </td> 
  </tr> 
  <tr> 
   <td>优先级</td> 
   <td>getPriority()</td> 
  </tr> 
  <tr> 
   <td>是否是后台线程</td> 
   <td>isDaemon()</td> 
  </tr> 
  <tr> 
   <td>是否存活</td> 
   <td>isAlive()</td> 
  </tr> 
  <tr> 
   <td>是否被中断</td> 
   <td>isInterrupted()</td> 
  </tr> 
 </tbody> 
</table>

> (1)I**D是线程的唯一标识,不同线程是不会重复的**(因为ID是jvm自动分配的身份标识,会保证身份的唯一性).
> 
> (2)名称是各种调试工具都要用到的重要属性
> 
> (3)状态表示线程当前所处的一个情况,之后我们将详细说明
> 
> (4)优先级高的线程理论上更容易被调度到(这个属性用的很少)
> 
> (5)isDaemon设置为true就是后台, daemon意为守护,可叫做守护线程(非常抽象),但更广泛的被叫为后台线程,与后台线程相对,还有前台线程.**后台线程其运行不会阻止进程结束,前台线程其运行会阻止进程结束**(jvm中内置的线程都是后台线程,不会阻止进程结束)**关于后台线程需要记住一点:JVM会在一个进程的所有非后台线程结束以后,才会结束运行.**  **而我们代码创建的线程默认是前台线程,会阻止进程结束,只要前台线程没有执行完,进程就不会结束.即使main已经执行完毕.**
> 
> (6)是否存活,最简单的理解,就是run方法是否运行结束了,高级的理解:就是表示内核中的线程(PCB)是否还存在

代码示例:

public class ThreadDemo {
        public static void main(String[] args) {
            Thread thread = new Thread(() -> {
               for(int i = 0; i < 10; i++) {
                   try {
                       Thread.sleep(1000);
                       System.out.println(Thread.currentThread().getName() + ": 我还活着");
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
                System.out.println(Thread.currentThread().getName() + ": 我即将死去");
            }, "一个不愿透漏姓名的神秘线程");
            System.out.println(Thread.currentThread().getName() + ": ID: " + thread.getId());
            System.out.println(Thread.currentThread().getName() + ": 名称: " + thread.getName());
            System.out.println(Thread.currentThread().getName() + ": 状态: " + thread.getState());
            System.out.println(Thread.currentThread().getName() + ": 优先级: " + thread.getPriority());
            System.out.println(Thread.currentThread().getName() + ": 后台线程: " + thread.isDaemon());
            System.out.println(Thread.currentThread().getName() + ": 活着: " + thread.isAlive());
            System.out.println(Thread.currentThread().getName() + ": 被中断: " + thread.isInterrupted());
    
            thread.start();
            while(thread.isAlive()) {
                System.out.println(Thread.currentThread().getName() + ": 状态: " + thread.getState());
            }
        }
    }

## 启动一个线程 - start() ##

**之前我们已经看到了如何通过覆写run方法创建一个线程对象,但是线程对象被创建出来并不意味着线程就开始运行了**.

> **start和run方法的区别.**
> 
> 1.覆写run方法是提供线程要做的事情的指令清单,调用run()实际上还是在main线程中,根本还是串行执行
> 
> 2.使用start()start方法才是真正意义上在操作系统底层创建了一个新线程.

## 终止一个线程 ##

**认为是让线程run方法(入口方法)执行完毕**

> 李四是X公司的一名员工,老板要求按步骤给某人转账.
> 
> 按理来说他会正常按照行动指南上的步骤去进行工作,不完成是不会结束的.但有时我们需要增加一些机制,例如老板突然来电话了,说转账的对方是个骗子,需要赶紧停止转账,那张三该如何通知李四停止呢?这就涉及到了我们停止线程的方式了.

目前常见的有以下两种方式:

**1.通过共享的标记来进行沟通**

**2.调用interrupt()方法来通知**

示例1:使用自定义的变量作为标志位.

public class ThreadDemo1 {
    
        public static boolean isQuit = false;
    
        public static void main(String[] args) {
    
            Thread t = new Thread(() -> {
                while(!isQuit) {
                    System.out.println(Thread.currentThread().getName() + ": 别管我,我忙着转账呢!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + ": 啊!险些误了大事!");
            }, "李四");
    
            System.out.println(Thread.currentThread().getName() + ": 让李四开始转账.");
            t.start();
            try {
                Thread.sleep(10 * 1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
    
            System.out.println(Thread.currentThread().getName() + ": 老板来电话了,得赶紧通知李四对方是个骗子!");
            isQuit = true;
        }
    }

**这个写法,不够优雅,Thread提供了更优雅的方法供我们选择.**

示例2:使用Thread.interrupted()或者Thread.currentThread().isInterrupted()代替自定义标志位 .

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

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td><strong>方法</strong></td> 
   <td><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td>public void interrupt()</td> 
   <td> <p>中断对象关联线程,如果线程正在阻塞,</p> <p>则抛出InterruptedException异常并清除中断标志</p> </td> 
  </tr> 
  <tr> 
   <td>public static boolean interrupted()</td> 
   <td>判断当前线程的中断标志位是否设置,并清除中断标志位</td> 
  </tr> 
  <tr> 
   <td>public boolean isInterrupted()</td> 
   <td>判断对象关联的线程的标志位是否设置,调用后不会清除中断标志</td> 
  </tr> 
 </tbody> 
</table>

使用thread对象的interrupted()方法通知线程结束

public class ThreadDemo3 {
        public static void main(String[] args) {
            Thread t1 = new Thread(() -> {
               while(!Thread.currentThread().isInterrupted()) {
                   System.out.println(Thread.currentThread().getName() + ": 别管我,我忙着转账呢!");
                   try {
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                       System.out.println(Thread.currentThread().getName() + ": 有内鬼,终止交易! ");
                       //注意此处的break,后面要讲
                       break;
                   }
               }
                System.out.println(Thread.currentThread().getName() + ": 啊!险些误了大事");
            }, "李四");
    
            t1.start();
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
    
            System.out.println(Thread.currentThread().getName() + ": 老板来电话了,得赶紧通知李四对方是个骗子");
            t1.interrupt();
        }
    }

Thread收到通知的方式有两种:

1. **如果线程因为调用wait/join/sleep等方法而阻塞挂起,则会以InterruptedException异常的形式通知,清除中断标志**.

> (在执行sleep的过程中,调用interrupt,大概率sleep休眠时间未到,被提前唤醒了.)
> 
> 提前唤醒,会出现两件事:1.抛出InterruptedException异常;2.清除Thread对象的isInterrupted标志位(通过interrupt已经设为true了,但是sleep提前唤醒操作,又会将标志位设为false)
> 
> **sleep清除标志位,是为了给程序员更多"可操作空间"**
> 
> **当出现InterruptedException时,要不要结束线程取决于catch中代码的写法,可以选择忽略这个异常,也可以跳出循环结束的线程**
> 
> **(1)加上break:让线程立即结束**
> 
> **(2)不加break:让线程不结束,继续执行**
> 
> **(3)写一些其它的代码再加break :让线程执行一些逻辑后结束**
> 
> 在实际开发中catch中的代码
> 
> (1)尝试自动恢复,就尽量自动恢复,比如出现了网络通信相关的异常,就在catch中尝试重连
> 
> (2)记录日志(将异常信息记录到文件中):有些问题不严重(不需要立即解决),先记下来,等程序猿有空再解决
> 
> (3)发出报警:比较严重了,将以短信电话等形式通知程序员,表明需要立即解决
> 
> (4)少数业务正常逻辑需要依赖catch

**2.否则,只是一个内部的一个中断标志被设置,thread可以通过**

> Thread.currentThread().isInterrupted判定指定线程的中断标志被设置,**不清除中断标志.这种方式通知收到更及时,即使线程正在sleep也可以马上收到**.

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

有时,我们需要等待一个线程完成它的工作之后,才能进行自己的下一步工作.而不是通过强行终止这个线程的方法(实际上强行终止一个线程也不科学).例如,张三只有等李四转账成功,才决定是否存钱,这时我们需要一个方法明确等待线程的结束.

举例:

public class TestDemo2 {
        public static void main(String[] args) throws InterruptedException {
            Runnable target = () -> {
               for(int i = 0; i < 5; i++) {
                   try {
                       System.out.println(Thread.currentThread().getName() + ": 我还在工作! ");
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       throw new RuntimeException(e);
                   }
               }
                System.out.println(Thread.currentThread().getName() + ": 我结束了");
            };
    
            Thread t1 = new Thread(target, "李四");
            Thread t2 = new Thread(target, "王五");
            System.out.println("先让李四开始工作");
            t1.start();
            t1.join();
            System.out.println("李四工作结束了,王五开始工作");
            t2.start();
            t2.join();
            System.out.println("王五工作结束了");
        }
    }

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td><strong>方法</strong></td> 
   <td><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td>public void join()</td> 
   <td>等待线程结束(就是死等,等不到不走)</td> 
  </tr> 
  <tr> 
   <td>public void join(long millis)</td> 
   <td>等待线程结束(最多等millis毫秒)</td> 
  </tr> 
  <tr> 
   <td>public void join(long millis, int nanos)</td> 
   <td>同理,可设置精度</td> 
  </tr> 
 </tbody> 
</table>

## 获取当前线程的引用 ##

利用下面的方法可以获得当前线程的实例,哪个线程调用就是哪个线程的实例.相信你们已经非常熟悉了.

> public static Thread currentThread();

## 休眠当前线程 ##

也是我们比较熟悉的方法,要记得:**因为线程调度是不可控的,所以,这个方法只能保证实际休眠时间是大于等于参数设置的休眠时间的**.

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td><strong>方法</strong></td> 
   <td> <p><strong>说明</strong></p> </td> 
  </tr> 
  <tr> 
   <td>public static void sleep(long millis)throws InterruptedException</td> 
   <td>休眠当前线程millis毫秒</td> 
  </tr> 
  <tr> 
   <td>public static void sleep(long millis)throws InterruptedException</td> 
   <td>更高精度</td> 
  </tr> 
 </tbody> 
</table>