【JavaEE】浅谈线程（二）

线程

线程的常见属性

线程属性可以通过下面的表格查看。
•ID 是线程的唯⼀标识，不同线程不会重复
• 名称是各种调试⼯具⽤到（如jconsoloe）
• 状态表示线程当前所处的⼀个情况，下⾯我们会进⼀步说明
• 优先级高的线程理论上来说更容易被调度到
• 关于后台线程，需要记住⼀点：JVM会在⼀个进程的所有非后台线程结束后，才会结束运⾏。
• 是否存活，即简单的理解，为 run 方法是否运⾏结束
• 线程的中断问题，下⾯我们进⼀步说明

线程的状态

线程状态分为New、Terminated、Runnable、Waiting、Timed_Waiting、Blocked

观测线程状态可以通过jconsole观察。

• New 该状态下存在Thread对象，还没有调用start，系统内部PCB还未创建
• Terminated 该状态下表示线程已终止，内部创建的PCB已经销毁，Thread对象还在
• Runnable 该状态下表示线程正在CPU上执行，随时可以被调度。
• Waiting 死等状态进入的阻塞
• Timed_Waiting 带有规定时间的等待
• Blocked 进行锁竞争后出现的阻塞状态

线程状态之间的转换图（省略版）

线程是否存活

在线程生命周期中，根据观察线程中的PCB是否存在。

Thread t = new Thread(()->{});

在这段代码中，线程t只是初始化了一个Thread对象，但是其中的PCB只有在执行了t.start()以后才会被创建出来。

public static void main(String[] args) {Thread t = new Thread(()->{});t.start();try {Thread.sleep(2000);} catch (InterruptedException e) {throw new RuntimeException(e);}}

在上面的代码中，线程t在启动以后创建了PCB，但是因为t中代码块没有任何代码，所以线程t很快就运行结束了，内核中的线程和PCB马上就被销毁了。而在main线程中，通过sleep停止了2s，因此线程t的PCB被销毁，而t这个对象并没有被gc回收，t仍然是存在的。
在下面的代码中，我加上了t=null，通过这个方法以求解决t对象能够被gc回收。但显然是不行的，通过t=null，可能会导致t线程还没结束，t对象就为空了。

public static void main(String[] args) {Thread t = new Thread(()->{});t.start();t = null;try {Thread.sleep(2000);} catch (InterruptedException e) {throw new RuntimeException(e);}}

因此，Thread给了我们一种属性：isAlive，是否存活。通过这个属性我们可以查看到线程是否存在，并对线程t进行操作。

public static void main(String[] args) throws InterruptedException {Thread t = new Thread(()->{for (int i = 0; i < 5; i++) {System.out.println("hello ");}System.out.println("线程t是否存活："+Thread.currentThread().isAlive());});t.start();Thread.sleep(3000);System.out.println("线程t是否存活："+ t.isAlive());}

结果如下图

前台线程和后台线程的关系与区别

线程是并发执行的。当然，当线程多了以后，为了能够不让某些线程影响整个进程的结束，更好的利用系统资源。于是为线程设计了前台和后台两个线程方式。在前台线程中，如果本线程运行没有结束，则此时Java进程也无法结束。在后台线程中，即使该线程还处于执行阶段，当前台线程都结束以后，意味着整个Java进程即将结束。那么这时候后台线程就不得不停止执行了。
简单来说，前台线程决定了Java进程的时间，后台线程无法控制整个进程的时间，只能被迫跟着前台线程的结束而结束。
前台线程也可以是多个的，只有最后一个前台线程结束，整个Java进程才结束。

设置线程的前后台

在Java中，main线程，以及默认情况下的线程都属于前台线程。而改变线程前后台的方式可以通过修改线程前后台属性： t.setDaemon(true) 将对应线程转变为后台线程。

接下来使用一个例子进行简单演示

public class Demo1 {public static void main(String[] args) {Thread t = new Thread(() -> {while (true) {for (int i = 0;i<5;i++) {System.out.println("hello thread");}}});t.setDaemon(true);t.start();for (int i = 0; i < 5; i++) {System.out.println("hello main");}}
}

在上面的代码中，我们可以看到，理论上来说线程t应当是进入死循环不断打印"hello thread"的，但是我在线程启动之前，将t线程设置为后台线程。因此，在main线程运行结束以后，垃圾回收机制gc将main线程回收，前台线程结束，后台线程t自然也只能被迫结束。

线程核心操作

启动 t.start()

通过多次的练习，已经明白t.start()执行后创建线程PCB，真正创建线程并开始执行。不再过多赘述

终止 interrupt()

在Java中，终止线程不是简单的停止线程的执行。而是对线程进行提醒，提醒线程是否停止，而真正做决定的还是该线程本身。
1）通过变量控制终止线程

	private static boolean isRunning=true;public static void main(String[] args) throws InterruptedException {// boolean isRunning = true;//变量捕获Thread t2 = new Thread(()->{while (isRunning) {System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("t2线程被结束了");});t2.start();Thread.sleep(4000);System.out.println("控制t2线程结束");isRunning = false;}

结果如下图

2）使用线程的interrupt和isInterrupted方法
通过下面的代码进行解释，在这个代码块中，线程t3通过isInterrupted判断是否结束这个循环，而在main线程中，通过t.interrupt方法，将这个值修改为false,抛出RuntimeException异常，结束了当前的线程。

public static void main(String[] args) throws InterruptedException {Thread t3 = new Thread(()->{while (!Thread.currentThread().isInterrupted()) {System.out.println("hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException();//抛出异常并结束}}System.out.println("t2线程被结束了");});t3.start();Thread.sleep(3000);t3.interrupt();}

3）提醒线程而不终止
在下面的代码中，修改了boolean之后，线程t3并没有停止线程，而是打印出异常信息之后继续执行。
在这里出现了一个问题，为什么通过interrupt方法之后修改了boolean值，但是在线程抛出异常之后仍然在继续打印呢？
首先，interrupt方法修改了boolean值的标志位修改为true，在slee过程中，通过interrupt方法强制唤醒线程，在强制唤醒后清除了刚刚的标志位，重新修正回flase。

public static void main(String[] args) throws InterruptedException {Thread t3 = new Thread(()->{while (!Thread.currentThread().isInterrupted()) {System.out.println("hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace(); //打印异常信息而不结束//throw new RuntimeException();//抛出异常并结束}}System.out.println("t2线程被结束了");});t3.start();Thread.sleep(3000);t3.interrupt();}

等待join()

因为线程是抢占式执行的，其调度顺序在系统中是无序的。而这种无序的执行方式不在程序猿的掌控之中，因此我们希望能够通过一些方式控制这些线程。join（等待）就是其中一种方式。

• 基本用法
  在下面的代码块中，分为main线程和t两个线程。我们可以注意到，与之前的写法其实是大差不差的，唯一区别的是在try-catch包裹下出现的t.join()方法。
  在main线程中使用t.join的作用让main线程进入阻塞等待状态，t线程执行完之后main线程才会接着往下执行。
  通过这样的方式在一定程度上解决了线程的控制问题。

public static void main(String[] args) {Thread t = new Thread(() -> {for (int i = 0; i < 5; i++) {System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("thread end");});t.start();try {t.join();} catch (InterruptedException e) {throw new RuntimeException(e);}for (int i = 0; i < 5; i++) {System.out.println("hello main");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("main end");}

因此我们可以看到结果如下图所示：

• 多个线程的join
  在多个线程等待代码了解之前，我们必须了解的是在main线程中调用t1.join，是main线程等待t1，而与其他线程无关，main线程是不会等待其他线程的。当多线程的情况下也是这般理解的。
  在下面的代码中，存在t1和t2两个线程，在main线程中，同时调用t1.join()和t2.join() 这意味着main线程只有等t1线程和t2线程全部执行完毕以后才会往下执行。t1和t2线程各自调度执行，互不影响。 所需的时间是t1线程和t2线程运行时间较长的。

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {for (int i = 0; i < 10; i++) {System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("t1 end");});Thread t2 = new Thread(() -> {for (int i = 0; i < 10; i++) {System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("t2 end");});t1.start();t2.start();t1.join();t2.join();for (int i = 0; i < 10; i++) {System.out.println("hello main");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("main end");}

• 有限时间内等待
  在上面两个情况下，对于t.join()的方法，只有等待线程t运行结束以后才能进行下一步，属于死等状态。那么如果出现意料之外的情况，线程t无法结束，那么整个程序都会因此卡住，无法执行后续的逻辑，极大降低了系统的容错。
  因此Java提供了join带参数的两种方法。通过这两种方法，当线程超过规定时间而不结束，则主线程不再等待，继续执行下面的逻辑。
  
  接下来简单写个demo
  在这个demo中，存在三个线程分别为t1、t2、main。在代码中我通过t1.join()让两个线程都进行阻塞状态等待线程t1结束。而对于t2，不相同的是我只让main线程等待2s，超过两秒之后，main线程不再是阻塞状态，而是执行下面的逻辑。

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {for (int i = 0; i < 5; i++) {System.out.println("hello t1");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("t1 end");});Thread t2 = new Thread(() -> {try {t1.join();} catch (InterruptedException e) {throw new RuntimeException(e);}for (int i = 0; i < 5; i++) {System.out.println("hello t2");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("t2 end");});t1.start();t2.start();t1.join();t2.join(2000);//等待2s后main线程自己走了for (int i = 0; i < 5; i++) {System.out.println("hello main");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("main end");}

因此代码结果如下：

总结

多线程有许多常见属性以及各类用法，都是需要熟练掌握的。
源码：多线程相关代码