"ava多线程基础-4：详解Thread类及其基本用法（二）

Java多线程基础-4：详解Thread类及其基本用法 （一）+ https://developer.aliyun.com/article/1520500?spm=a2c6h.13148508.setting.14.61564f0eYtukUb

2、线程中断        interrupt()

线程的中断就是字面意思：让一个线程停下来。也即线程的终止。（它与操作系统中的概念“中断”不是一个意思。）

本质上来说，让一个线程终止的唯一方法是让该线程的入口方法run()执行完毕。基于这个思路，我们可以尝试用以下的方式终止线程：

（1）给线程中设定一个结束标志位 isQuit

先创建一个线程 t ：

注意：该线程 t 的代码是死循环，死循环导致 t 的入口方法 run() 永远无法结束，因此该线程也永远不会结束。但，我们可以将循环条件用一个变量 isQuit 来控制。类似一个手动控制的开关，当 !isQuit 为true时，执行循环体内的逻辑；当 !isQuit 为false时则跳出。演示代码如下：

public class ThreadDemo {
    //控制变量 isQuit
    public static boolean isQuit = false;
 
    public static void main(String[] args){
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("hello t!");
                try {
                    Thread.sleep(1000); //让线程休眠1000毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
 
            System.out.println("t 线程终止！！");
        });
 
        t.start();
 
        // 在main线程中修改 isQuit,从而起到控制 t线程 的效果
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        isQuit = true;
    }
}

打印了3次"hello t!"后，!isQuit 被更改为了false。t 线程中的循环终止，打印"t 线程终止！！"后 t 线程结束。此时main线程也结束了，因此整个进程也随之结束，输出的运行结果如下：

（2）注意 isQuit 的书写位置

这里的变量 isQuit 写作了成员变量。为什么不将 isQuit 写成 main 方法中的局部变量呢？

当我们尝试将 isQuit 写成 main 方法中的局部变量时，可以看到，出现了编译错误。

这个编译错误要特别说明：

有些同学可能认为，出现该编译错误是因为使用变量超出了它的作用域，但事实并非如此。线程 t 是可以正常拿到main线程中的变量的，因为同一进程的线程和线程之间共用内存地址空间，线程1创建出来的变量在线程2中也能访问（内存地址共用，变量也共用）。

正确的原因是变量捕获。lambda表达式能否访问它外面的局部变量？答案是可以，这里就涉及到了变量捕获这一语法规则。Java语法要求变量捕获，捕获到的变量必须是final或实际final(effectively final)。实际final指的是，虽然一个变量没有用final关键字修饰，但是代码中并没有尝试过修改它（没有做出过修改）。

在上面报错的代码中，我们在最后一行作出了修改isQuit的操作，这违背了变量捕获的语法要求，因此变量捕获失败了，程序编译报错。

解决方式就是按照一开始的，将isQuit写作成员变量，这样main中的程序访问成员变量就不受变量捕获规则的限制，也就不会存在上述问题了。

（3）使用Thread类内置的标志位 isInterrupted()

isInterrupted()就可以理解为，是t对象自带的一个结束标志位。通过 t.interrupt() 方法将t内部的标志位给设定成 true。

演示代码如下：

public class ThreadDemo {
    public static void main(String[] args){
        Thread t = new Thread(() -> {
            // currentThread()是获取到当前对象的实例
            // 此处，currentThread()得到的对象就是 t
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("hello t!");
                try {
                    Thread.sleep(1000); //让线程休眠1000毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
 
            System.out.println("t 线程终止！！");
        });
 
        t.start();
 
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
    }
}

事实上，此时我们运行程序，并不会出现我们想要的线程中断的效果：

可以看到，当3秒钟时间到，调用 t.interrupt() 方法时，线程并没有终止，而是在打印了异常信息后，继续执行了。

运行结果中的这个异常信息，正是while循环中的catch捕获并打印的：

（4）interrupt() 方法的作用

其实，interrupt() 方法不仅会改变线程内部的标志位，还会将sleep()唤醒。这是上述异常来源的原因。

interrupt()方法的作用：

设置标志位为true

如果该线程正在阻塞状态中（如正在执行sleep，join，wait等），此时就会把该线程从阻塞状态唤醒，并通过抛出异常的方式让sleep立即结束。

换句话说，如果interrupt()执行时，t线程正在sleep，那么interrupt()在将标志位设置为true后，又会直接将sleep强行唤醒。sleep在该程序中，占据了绝绝绝大部分的时间，因此当interrupt()执行时，几乎一定会遇到正在sleep的情况。注意：当sleep被提前唤醒的时候，sleep会自动把isInterrupted标志位再次清空（即把true又变为false）。这就导致了下次再判断循环条件，循环条件还成立，因此循环还在继续执行。

这就好比有一天早上你关着灯拉着窗帘在床上睡大觉，本来你打算睡到8点，结果凌晨5点你妈妈就走进你的房间喊你起床，还把灯啪的一下给你打开了。你坐起来一看才5点，于是又随手把灯关了。

由于主线程只调用了一次interrupt()，因此在抛出一次异常后，后面就不会再次抛出异常了。

如果需要结束循环，则必须catch{}中，加一个break。

如图，实现了循环结束，线程终止。

（5）为什么sleep()要清空标志位呢？

这么做的目的是为了让线程自身能够对于线程何时结束有一个更明确灵活的控制。

事实上，当前interrupt方法的效果并不是让线程立即结束，而是“通知建议”性质的，告诉线程“你该结束了”。至于线程是否真的要立即结束，都是可以通过代码来灵活控制的，否则就太僵硬了。interrupt只是通知，而不是命令。

比如有一天你正在打游戏，你的妈妈突然喊你去超市买酱油。这时你可以灵活选择：1、等一会儿再去；2、直接忽视；3、立马就去。代码也是一样：

线程t 何时结束，交给线程t 自己来决定。

3、线程等待        join()

（1）join()方法，无参数

对于如下代码，线程之间是并发执行的，操作系统对于线程的调度是无序的，无法判断两个线程谁先执行结束，谁后执行结束。先打印出"hello t!"还是"hello main!"，是无法确定的。

有些同学可能运行过代码后发现，结果总是先输出"hello main!"，再输出"hello t!"。这是因为线程t的创建也有一定的开销，这导致"hello t!"可能略慢一筹。但并不排除某些特定情况下，"hello main!"没有立即执行到。换句话说，即使大部分情况下先输出了"hello main!"，也无法判断下一次到底先输出哪个线程的运行结果。

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello t!");
        });
 
        t.start();
 
        System.out.println("hello main!");
    }
}

这是一个并不受欢迎的问题。因为有的时候，就需要明确规定线程的结束顺序。这时，就可以通过线程等待join()来实现。

在main线程中，我们调用t.join()，意思是让main线程等待 t 先结束，再往下执行，而别的线程不受影响。在 t.join() 执行的时候，如果 t 线程还没结束，main线程就会阻塞(Blocking)等待。可以理解为：代码走到这一行就停下来，当前线程就暂时不参与CPU的调度执行了。

此时，程序的输出结果就是确定的了，即先输出"hello t!"再输出"hello main!"

情况分析

注意这里线程之间的等待关系：如果在 t1 线程中调用 t2.join()，就是让 t1 线程等待 t2 线程先结束（t1 进入阻塞，其它线程正常调度）。谁.join()，就等待谁；在谁中写 t.join() 这个语句，谁就阻塞等待。

这里的join()方法是无参的，它的效果是“死等”，“不见不散”；如果 t线程一直不结束，main线程就一直等待 t线程，直到等到为止。可以用如下代码演示：

线程t 执行死循环，一直不会结束，此时控制台就空空如也，由于线程的等待，"hello main!"不输出

（2）join()方法，带参数

join()方法还有一个版本，可以填写一个参数作为“超时时间”，也就是等待的最大时间。如果等待的时间已经到达了这个时间上限但还没等到，也就不等了。如以下代码演示：

3秒钟之后，main线程不再等待t线程，打印出"hello main!"

有时也会有两个线程互相阻塞等待的情况，称之为“死锁”，是一种程序bug。

4、线程休眠        sleep()

sleep()线程休眠的方法前面已经使用过。需要注意的有两点，一是该方法是Thread类的一个静态方法，由Thread类名直接调用：Thread.sleep()；二是该方法存在一个受查异常，在使用这个方法时，需要try-catch或throw来处理这个异常。

5、获取线程实例        currentThread()

前面我们也已经提到过了这个方法。它能获取当前线程对象的实例。在哪个线程里调用，得到的就是哪个线程对象的实例。需要的注意的是，该方法是Thread类的静态方法，由Thread类直接调用。

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = Thread.currentThread();    //获取当前对象实例
        System.out.println(thread.getName());
   }
}