Thread类和线程状态

news2024/11/22 22:13:31

Thread 的常见构造方法

Thread 的几个常见属性

经典面试题：start和run的区别

interrupt 线程中断

join 线程等待

currentThread 获得当前这个线程对应的 Thread 对象的引用。

sleep 置顶休眠的时间(阻塞一会)

sleep(1000)，真的只是休眠1000毫秒吗？

线程状态

我的GitHub：Powerveil · GitHub

我的Gitee：Powercs12 (powercs12) - Gitee.com

皮卡丘每天学Java

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

Thread 的常见构造方法

方法	说明
Thread()	创建线程对象
Thread(Runnable targer)	使用 Runnable 对象创建线程对象
Thread(String name)	创建线程对象，并命名
Thread(Runnable target, String name)	使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group, Runnable target)	线程可以被用来分组管理，分好的组即为线程组，了解即可

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

Thread 的几个常见属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否后台线程(守护线程)	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

ID 是线程的唯一标识，不同线程不会重复
名称是各种调试工具用到
状态表示线程当前所处的一个情况，下面我们会进一步说明
优先级高的线程理论上来说更容易被调度到
关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
是否存活，即简单的理解，为 run 方法是否运行结束了
线程的中断问题，下面我们进一步说明

注意：

这里的 id 是 Java 中给 Thread 对象安排的身份标识，和操作系统内核中的 PCB 的 pid，以及和操作系统提供的线程 API 中的线程id 都不是一回事。身份标识可以有多个，在不同的环境下，使用不同的标识。

一个线程：

在 JVM 中有个 id
在操作系统的进程 API 有个 id
内核 PCB 中还有个 id

这三个 id 效果一样，但是在不同的环境下使用。

后台线程(守护线程)

这里的Daemon(守护)，

默认创建的线程是“前台线程” 前台线程会阻止进程退出，如果 main 运行完了，前台线程还没完，进程不会退出。

如果是后台线程，后台线程不阻止进程退出，如果 main 等其他的前台线程执行完了，这个时候，即使后台线程没执行完，进程也会退出

前台线程可以有很多个(main 也是一个前台线程)

后台线程也可以有很多(GC 也是一个后台线程)

线程是否存活 isAlive 判定内核的线程在不在

Thread 对象虽然和内核中的线程是一一对应的关系，但是生命周期并非完全相同

Thread 对象出来了，内核里的线程还不一定有，调用 start 方法，内核线程才有，当内核里的线程执行完了(run 运行完了)，内核的线程就销毁了，但是 Thread 对象还在

调用 start 才会真正创建线程，不调用 start 没创建线程(在内核里创建 PCB)

经典面试题：start和run的区别

直接调用 run 并没有创建线程，只是在原来的线程中运行的代码调用 start 则是创建了线程，在新线程中执行代码(和原来的线程是并发的)

interrupt 线程中断

run 方法执行完了，线程就结束了，有没有办法，让线程提前一点结束呢？就是通过线程中断的方式来进行(本质仍然是让 run 方法尽快结束，而不是 run 执行一半，强制结束) 这就取决于 run 里面的具体是如何实现的了

1.直接自己定义一个标志位，作为线程是否结束的标记

 public class Demo10 {
     private static boolean isQuit = false; // 自定义标志位
     public static void main(String[] args) {
         Thread t = new Thread(() -> {
             while (!isQuit) {
                 System.out.println("hello thread");
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             System.out.println("t 线程执行完了");
         });
 
         t.start();
 
         try {
             Thread.sleep(3000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
         isQuit = true;
         System.out.println("设置让 t 线程结束!");
     }
 }

2.还可以使用标准库里面自带的一个标志位

Thread.currentThread().isInterrupted()

在主线程中，通过 t.interrupt() 来中断这个线程，设置标志位 true

 public class Demo11 {
     public static void main(String[] args) {
         Thread t = new Thread(() -> {
             while (!Thread.currentThread().isInterrupted()) {
                 System.out.println("hello thread");
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     // e.printStackTrace();
 
                     // [方式一] 立即结束线程
                     break;
 
                     // [方式二] 啥都不做, 不做理会. 线程继续执行
 
                     // [方式三] 线程稍后处理
                     // Thread.sleep(1000);
                     // break;
                 }
             }
             System.out.println("t 线程执行完了");
         });
 
         t.start();
 
         try {
             Thread.sleep(3000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
         t.interrupt();
         System.out.println("设置让 t 线程结束!");
     }
 }

interrupt 方法的行为有两种情况

t 线程在运行状态会设置

Thread.currentThread().isInterrupted()

标志位为 true
t 线程在阻塞状态 (sleep)

不会设置标志位，而是触发一个InterruptedException

这个异常会发 sleep 提前唤醒

第一种情况，直接中断循环

第二种情况：打断sleep，但是没有结束循环

在 Java 中，中断线程并非是强制的，由线程自身的代码来进行判定处理的

线程自身能怎么处理呢？

立即结束线程
不理会
稍后理会

却决于代码怎么写

join 线程等待

线程之间的调度顺序，是不确定的但是可以通过一些特殊操作来对线程的执行顺序做出干预，其中 join 就是一个办法，控制线程之间的结束顺序

 public class Demo {
     public static void main(String[] args) {
         Thread t = new Thread(() -> {
             for (int i = 0; i < 5; i++) {
                 System.out.println("hello power!");
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         });
         t.start();
 
         System.out.println("main 线程 join 之前");
         try {
             t.join();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("main 线程 join 之后");
     }
 }