15.4 线程的中断

发表于 2021-12-06 更新于 2021-12-08 分类于 9 Java编程的逻辑， 5第五部分并发，第15章并发基础知识 Waline：本文字数： 4.9k 阅读时长 ≈ 4 分钟

15.4 线程的中断

本节主要讨论一个问题，如何在Java中取消或关闭一个线程？我们先介绍都有哪些场景需要取消/关闭线程，再介绍取消/关闭的机制，以及线程对中断的反应，最后讨论如何正确地取消/关闭线程。

15.4.1 取消/关闭的场景

我们知道，通过线程的start方法启动一个线程后，线程开始执行run方法，run方法运行结束后线程退出，那为什么还需要结束一个线程呢？有多种情况，比如：
1）很多线程的运行模式是死循环，比如在生产者/消费者模式中，消费者主体就是一个死循环，它不停地从队列中接受任务，执行任务，在停止程序时，我们需要一种“优雅”的方法以关闭该线程。
2）在一些图形用户界面程序中，线程是用户启动的，完成一些任务，比如从远程服务器上下载一个文件，在下载过程中，用户可能会希望取消该任务。
3）在一些场景中，比如从第三方服务器查询一个结果，我们希望在限定的时间内得到结果，如果得不到，我们会希望取消该任务。
4）有时，我们会启动多个线程做同一件事，比如类似抢火车票，我们可能会让多个好友帮忙从多个渠道买火车票，只要有一个渠道买到了，我们会通知取消其他渠道。

15.4.2 取消/关闭的机制

Java的Thread类定义了如下方法：

1	public final void stop()

这个方法看上去就可以停止线程，但这个方法被标记为了过时，简单地说，我们不应该使用它，可以忽略它。

在Java中，停止一个线程的主要机制是中断，中断并不是强迫终止一个线程，它是一种协作机制，是给线程传递一个取消信号，但是由线程来决定如何以及何时退出。本节我们主要就是来理解Java的中断机制。

Thread类定义了如下关于中断的方法：

1
2
3

public boolean isInterrupted()
public void interrupt()
public static boolean interrupted()

这三个方法名字类似，比较容易混淆，我们解释一下。isInterrupted()和interrupt()是实例方法，调用它们需要通过线程对象；interrupted()是静态方法，实际会调用Thread. currentThread()操作当前线程。

每个线程都有一个标志位，表示该线程是否被中断了。
1）isInterrupted：返回对应线程的中断标志位是否为true。
2）interrupted：返回当前线程的中断标志位是否为true，但它还有一个重要的副作用，就是清空中断标志位，也就是说，连续两次调用interrupted()，第一次返回的结果为true，第二次一般就是false（除非同时又发生了一次中断）。
3）interrupt：表示中断对应的线程。中断具体意味着什么呢？下面我们进一步来说明。

15.4.3 线程对中断的反应

interrupt()对线程的影响与线程的状态和在进行的IO操作有关。我们主要考虑线程的状态，IO操作的影响和具体IO以及操作系统有关，我们就不讨论了。线程状态有：

RUNNABLE：线程在运行或具备运行条件只是在等待操作系统调度。
WAITING/TIMED_WAITING：线程在等待某个条件或超时。
BLOCKED：线程在等待锁，试图进入同步块。
NEW/TERMINATED：线程还未启动或已结束。

1. RUNNABLE

如果线程在运行中，且没有执行IO操作，interrupt()只是会设置线程的中断标志位，没有任何其他作用。线程应该在运行过程中合适的位置检查中断标志位，比如，如果主体代码是一个循环，可以在循环开始处进行检查，如下所示：

public final void stop()
public boolean isInterrupted()
public void interrupt()
public static boolean interrupted()
public class InterruptRunnableDemo extends Thread {
    @Override
    public void run() {
        while(! Thread.currentThread().isInterrupted()) {
            //…单次循环代码
        }
        System.out.println("done ");
    }
    //其他代码
}

2. WAITING/TIMED_WAITING

线程调用join/wait/sleep方法会进入WAITING或TIMED_WAITING状态，在这些状态时，对线程对象调用interrupt()会使得该线程抛出InterruptedException。需要注意的是，抛出异常后，中断标志位会被清空，而不是被设置。比如，执行如下代码：

Thread t = new Thread (){
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.out.println(isInterrupted());
        }
    }
};
t.start();
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
}
t.interrupt();

程序的输出为false。

InterruptedException是一个受检异常，线程必须进行处理。我们在异常处理中介绍过，处理异常的基本思路是：如果知道怎么处理，就进行处理，如果不知道，就应该向上传递，通常情况下不应该捕获异常然后忽略。

捕获到InterruptedException，通常表示希望结束该线程，线程大致有两种处理方式：
1）向上传递该异常，这使得该方法也变成了一个可中断的方法，需要调用者进行处理；
2）有些情况，不能向上传递异常，比如Thread的run方法，它的声明是固定的，不能抛出任何受检异常，这时，应该捕获异常，进行合适的清理操作，清理后，一般应该调用Thread的interrupt方法设置中断标志位，使得其他代码有办法知道它发生了中断。

第一种方式的示例代码如下：

public void interruptibleMethod() throws InterruptedException{
    //…包含wait, join 或 sleep 方法
    Thread.sleep(1000);
}

第二种方式的示例代码如下：

public class InterruptWaitingDemo extends Thread {
    @Override
    public void run() {
        while(! Thread.currentThread().isInterrupted()) {
            try {
                //模拟任务代码
                Thread.sleep(2000);
            } catch(InterruptedException e) {
                //…清理操作
                //重设中断标志位
                Thread.currentThread().interrupt();
            }
        }
        System.out.println(isInterrupted());
    }
    //其他代码
}

3. BLOCKED

如果线程在等待锁，对线程对象调用interrupt()只是会设置线程的中断标志位，线程依然会处于BLOCKED状态，也就是说，interrupt()并不能使一个在等待锁的线程真正“中断”。我们看段代码：

public class InterruptSynchronizedDemo {
    private static Object lock = new Object();
    private static class A extends Thread {
        @Override
        public void run() {
            synchronized (lock) {
                while (! Thread.currentThread().isInterrupted()) {
                }
            }
            System.out.println("exit");
        }
    }
    public static void test() throws InterruptedException {
        synchronized (lock) {
            A a = new A();
            a.start();
            Thread.sleep(1000);
            a.interrupt();
            a.join();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        test();
    }
}

test方法在持有锁lock的情况下启动线程a，而线程a也去尝试获得锁lock，所以会进入锁等待队列，随后test调用线程a的interrupt方法并调用join等待线程线程a结束，线程a会结束吗？不会，interrupt方法只会设置线程的中断标志，而并不会使它从锁等待队列中出来。

在使用synchronized关键字获取锁的过程中不响应中断请求，这是synchronized的局限性。如果这对程序是一个问题，应该使用显式锁。第16章会介绍显式锁Lock接口，它支持以响应中断的方式获取锁。

4. NEW/TERMINATE

如果线程尚未启动（NEW），或者已经结束（TERMINATED），则调用interrupt()对它没有任何效果，中断标志位也不会被设置。

15.4.4 如何正确地取消/关闭线程

interrupt方法不一定会真正“中断”线程，它只是一种协作机制，如果不明白线程在做什么，不应该贸然地调用线程的interrupt方法，以为这样就能取消线程。

对于以线程提供服务的程序模块而言，它应该封装取消/关闭操作，提供单独的取消/关闭方法给调用者，外部调用者应该调用这些方法而不是直接调用interrupt。Java并发库的一些代码就提供了单独的取消/关闭方法，比如，Future接口提供了如下方法以取消任务：

1	boolean cancel(boolean mayInterruptIfRunning);

再如，ExecutorService提供了如下两个关闭方法：

1 2	void shutdown(); List<Runnable> shutdownNow();

Future和ExecutorService的API文档对这些方法都进行了详细说明，这是我们应该学习的方式。关于这两个接口，我们后续章节介绍。

15.4.5 小结

本节主要介绍了在Java中如何取消/关闭线程，主要依赖的技术是中断，但它是一种协作机制，不会强迫终止线程，我们介绍了线程在不同状态下对中断的反应。作为线程的实现者，应该提供明确的取消/关闭方法，并用文档描述清楚其行为；作为线程的调用者，应该使用其取消/关闭方法，而不是贸然调用interrupt。

至此，关于线程的基础内容就介绍完了。在Java中还有一套并发工具包，位于包java.util.concurrent下，里面包括很多易用且高性能的并发开发工具，从下一章开始，我们就来讨论它，先从最基本的原子变量和CAS（Compare And Set）操作开始。