java线程中断

tomjourney

已于 2022-02-20 18:07:41 修改

阅读量1k

点赞数 1

分类专栏： java并发编程实战文章标签： java 开发语言后端

于 2022-02-20 12:07:09 首次发布

本文链接：https://blog.csdn.net/PacosonSWJTU/article/details/123027663

版权

java并发编程实战专栏收录该内容

8 篇文章 1 订阅

订阅专栏

本文详细探讨了Java线程中断机制，包括在非阻塞、阻塞、IO阻塞和死锁状态下的中断处理。分析了thread.interrupt()方法在不同场景下的效果，如在循环、sleep、wait、IO操作中的应用，并提供了示例代码。同时，解释了中断状态如何影响线程执行，以及如何通过设置中断状态和捕获异常来优雅地退出线程。

摘要由CSDN通过智能技术生成

【README】

本文po出了不同场景下线程中断的不同开发方式，包括阻塞，非阻塞，io阻塞线程等；

本文部分内容转自：这篇博文写的非常好

Thread的中断机制(interrupt) - 寂静沙滩 - 博客园先看收集了别人的文章，全面的了解下java的中断：中断线程线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务https://www.cnblogs.com/onlywujun/p/3565082.html

【1】使用thread.interrupt()中断【非】阻塞状态线程

子线程不调用 sleep，wait 等方法就不会进入阻塞状态；

本文使用 while() 循环模拟 sleep睡眠方法, 如 tag1代码；

public class Example02 extends Thread {
    public static void main(String[] args) throws InterruptedException {
        Example02 thread = new Example02();
        System.out.println("【主线程】starting thread");
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        // 发出中断请求
        thread.interrupt(); // tag0  
        System.out.println("【主线程】发出中断请求后");
        TimeUnit.SECONDS.sleep(3);
        System.out.println("【主线程】随眠3秒后");
        System.out.println("【主线程】stoping thread");
    }
    @Override
    public void run() {
        while(!Thread.currentThread().isInterrupted()) {  // tag2 
            long start = System.currentTimeMillis();
            while(System.currentTimeMillis() - start < 500); // tag1 
            System.out.println("【子线程】running");
        }
        System.out.println("【子线程】current thread exit.");
    }
}

【代码解说】

tag0代码，调用 interrupt 之后，子线程的中断状态会设置为true；
只要不调用阻塞方法，如 sleep，wait 等方法就不会抛出中断异常；（即调用 thread.interrupt方法是不会让线程中断的，仅仅是设置了中断状态而已）
但tag2判断为false（因为中断状态为true），所以子线程结束循环，正常退出；

【2】使用thread.interrupt()中断阻塞状态线程

线程调用 sleep， wait 方法都可以进入阻塞状态；

/**
 * @Description 使用 thread.interrupt() 中断阻塞状态线程，捕获 InterruptedException 异常
 * @author xiao tang
 * @version 1.0.0
 * @createTime 2022年02月20日
 */
public class Example02_2 extends Thread {
    public static void main(String[] args) throws InterruptedException {
        Example02_2 thread = new Example02_2();
        System.out.println("【主线程】starting thread");
        thread.start();
        TimeUnit.SECONDS.sleep(3);
        // 发出中断请求
        thread.interrupt(); // tag0 
        System.out.println("【主线程】发出中断请求后");
        TimeUnit.SECONDS.sleep(3);
        System.out.println("【主线程】随眠3秒后");
        System.out.println("【主线程】stoping thread");
    }
    @Override
    public void run() {
        while(!Thread.currentThread().isInterrupted()) { // tag1 
            try {
                TimeUnit.MILLISECONDS.sleep(500); // 可中断式阻塞 tag2
            } catch (InterruptedException e) { // tag3 
                System.out.println("抛出中断异常，线程中断状态=" + Thread.currentThread().isInterrupted()); // false 
            }
            System.out.println("【子线程】running");
        }
        System.out.println("【子线程】current thread exit.");
    }
}

【代码解说】

情况1：主线程tag0代码执行后，设置线程中断状态为true；子线程立马执行tag1，循环结束，子线程退出；（子线程被中断，正常退出）

情况2：主线程tag0代码执行后，设置线程中断状态为true；子线程调用Thread.sleep(500) 会抛出中断异常 InterruptedException（因为中断状态为true），而抛出InterruptedException异常后，java底层会把中断标示位会自动清除（中断状态设置false）；接着 while循环中的 !Thread.currentThread().isInterrupted() 为判断为true，接着继续执行循环体逻辑；（子线程被中断，无法正常退出）

如何解决情况2中的子线程无法正常退出的情况？

在情况2的catch块中调用

Thread.currentThread().interrupt();//重新设置中断状态为true

重新设置中断状态为true ；然后while的判断语句就会判断为false，结束死循环，从而子线程才可以正常退出；

当然，如果业务逻辑不需要让子线程结束，即便遇到中断的话，无需添加 Thread.currentThread().interrupt() 代码；

【3】死锁状态线程无法被中断

/**
 * @Description 死锁状态线程无法被中断
 * @author xiao tang
 * @version 1.0.0
 * @createTime 2022年02月20日
 */
public class Example03_DeadLock {
    static class MyLock {
        String name;
        MyLock(String name) {
            this.name = name;
        }
    }
    public static void main(String[] args) {
        final MyLock lock1 = new MyLock("锁1");
        final MyLock lock2 = new MyLock("锁2");
        // 线程1
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                lock(lock1, lock2); // 传入锁的顺序不一样 
            }
        }, "线程1");
        // 线程2
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                lock(lock2, lock1); // 传入锁的顺序不一样
            }
        }, "线程2");
        // 开启线程
        t1.start();
        t2.start();
        // 中断线程
        t1.interrupt(); // 设置线程1的中断状态为true
        t2.interrupt(); // 设置线程2的中断状态为true
        System.out.println("【主线程】执行完成");
    }

    static void lock(MyLock lock1, MyLock lock2) {
        synchronized (lock1) { // 获得锁1
            System.out.println(Thread.currentThread().getName() + "获得" + lock1.name);
            // 获取锁2前先睡眠3秒 以便线程2获取锁1，才能模拟出死锁
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
            }
            synchronized (lock2) { // 获得锁2
                System.out.println(Thread.currentThread().getName() + "获得" + lock2.name);
            }
        }
    }
}

线程1与线程2阻塞，程序无法正常结束；

【4】中断IO阻塞的线程

/**
 * @Description 中断IO阻塞线程
 * @author xiao tang
 * @version 1.0.0
 * @createTime 2022年02月20日
 */
public class Eaxmple04_IOBlock extends Thread {
    volatile ServerSocket serverSocket; // 服务器套接字

    public static void main(String[] args) throws Exception {
        Eaxmple04_IOBlock ioBlockThread = new Eaxmple04_IOBlock();
        ioBlockThread.start();
        // 主线程睡眠等待子线程打开套接字
        TimeUnit.SECONDS.sleep(3);
        // 中断子线程
        ioBlockThread.interrupt(); // 中断 tat0
//        ioBlockThread.serverSocket.close(); // tag3
        System.out.println("【主线程】关闭了服务器套接字");
        System.out.println("【主线程】结束");
    }

    @Override
    public void run() {
        try {
            serverSocket = new ServerSocket(8080);
        } catch (IOException e) {
            System.out.println("【子线程】打开套接字失败，直接返回");
            return ;
        }
        while(!Thread.currentThread().isInterrupted()) { // tag2
            try {
                System.out.println("【子线程】接收客户端请求");
                serverSocket.accept();
            } catch (IOException e) { // 抛出IO异常后， java底层会把当前线程中断状态重置为false(清空)
                System.out.println("【子线程】accept()遇到io异常");
//                Thread.currentThread().interrupt(); // 重新设置当前线程中断状态为true  tag1
            } finally {
                try {
                    serverSocket.close();
                    System.out.println("【子线程】服务器套接字关闭");
                } catch (IOException e) {
                    System.out.println("【子线程】服务器套接字关闭出现异常");
                }
            }
        }
        System.out.println("【子线程】io thread结束");
    }
}

【注】注释了 tag3 tag1 的代码；

以上代码的子线程无法正常结束；

服务器套接字 ServerSocket.accept() 没有抛出 InterruptedException 中断异常，所以它是非中断式阻塞；所以 accept() 一直阻塞（子线程也一直阻塞），无法中断；

解决方法：

添加 tag3代码，主线程关闭服务器套接字；

ioBlockThread.serverSocket.close(); // tag3

且添加 tag1代码重新设置当前线程中断状态为true；如下：

Thread.currentThread().interrupt(); // 重新设置当前线程中断状态为true  tag1

因为抛出 IOException状态后，需要重新把当前线程中断状态设置为true，以便退出while循环，从而子线程才会正常结束；

注意：tag0的代码 ioBlockThread.interrupt() 不能删除，一旦删除，子线程将无法正常退出，可自行实验；

【4.1】如何中断IO操作（使用可中断通道）

中断I/O操作

然而，如果线程在I/O操作进行时被阻塞，又会如何？I/O操作可以阻塞线程一段相当长的时间，特别是牵扯到网络应用时。例如，服务器可能需要等待一个请求（request），又或者，一个网络应用程序可能要等待远端主机的响应。

实现此InterruptibleChannel接口的通道是可中断的：如果某个线程在可中断通道上因调用某个阻塞的 I/O 操作（常见的操作一般有这些：serverSocketChannel. accept()、socketChannel.connect、socketChannel.open、socketChannel.read、socketChannel.write、fileChannel.read、fileChannel.write）而进入阻塞状态，而另一个线程又调用了该阻塞线程的 interrupt 方法，这将导致该通道被关闭，并且已阻塞线程接将会收到ClosedByInterruptException，并且设置已阻塞线程的中断状态。另外，如果已设置某个线程的中断状态并且它在通道上调用某个阻塞的 I/O 操作，则该通道将关闭并且该线程立即接收到 ClosedByInterruptException；并仍然设置其中断状态。如果情况是这样，其代码的逻辑和第三个例子中的是一样的，只是异常不同而已。

如果你正使用通道（channels）（这是在Java 1.4中引入的新的I/O API），那么被阻塞的线程将收到一个ClosedByInterruptException异常。但是，如果你使用Java1.0之前就存在的传统的I/O，而且要求更多的工作。既然这样，Thread.interrupt()将不起作用，因为线程将不会退出被阻塞状态。尽管interrupt()被调用，线程也不会退出被阻塞状态，比如ServerSocket的accept方法根本不抛出异常。

很幸运，Java平台为这种情形提供了一项解决方案，即调用阻塞该线程的套接字的close()方法。在这种情形下，如果线程被I/O操作阻塞，当调用该套接字的close方法时，该线程在调用accept地方法将接收到一个SocketException（SocketException为IOException的子异常）异常，这与使用interrupt()方法引起一个InterruptedException异常被抛出非常相似，（注，如果是流因读写阻塞后，调用流的close方法也会被阻塞，根本不能调用，更不会抛IOExcepiton，此种情况下怎样中断？我想可以转换为通道来操作流可以解决，比如文件通道）。下面是具体实现：如 Eaxmple04_IOBlock

【5】小结

一、没有任何语言定义了一个被中断的线程应该终止。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断。
二、对于处于sleep，join等操作的线程，如果被调用interrupt()后，会抛出InterruptedException，然后线程的中断标志位会由true重置为false（只要抛出中断异常，则中断标识修改为false，即清空中断标识），因为线程为了处理异常已经重新处于就绪状态。
三、不可中断的操作，包括进入synchronized段以及Lock.lock()，inputSteam.read()等，调用interrupt()对于这几个问题无效，因为它们都不抛出中断异常。如果拿不到资源，它们会无限期阻塞下去。
四：可中断操作：对于Lock.lock()，可以改用Lock.lockInterruptibly()，可被中断的加锁操作，它可以抛出中断异常。等同于等待时间无限长的Lock.tryLock(long time, TimeUnit unit)。对于inputStream等资源，有些(实现了 InterruptibleChannel 接口)可以通过close()方法将资源关闭，对应的阻塞也会被放开。

【5.1】Thread类里的几个方法：

public static boolean interrupted： 测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false。
public boolean isInterrupted()： 测试线程是否已经中断。线程的中断状态 不受该方法的影响。
public void interrupt()： 中断线程。

上面列出了与中断有关的几个方法及其行为，可以看到interrupt是中断线程。如果不了解Java的中断机制，这样的一种解释极容易造成误解，认为调用了线程的interrupt方法就一定会中断线程。

【5.2】其实，Java的中断是一种协作机制。

也就是说调用线程对象的interrupt方法并不一定就中断了正在运行的线程，它只是要求线程自己在合适的时机中断自己。每个线程都有一个boolean的中断状态（这个状态不在Thread的属性上），interrupt方法仅仅只是将该状态置为true。比如对正常运行的线程调用interrupt()并不能终止他，只是改变了interrupt标示符。

【5.3】如何判断一个方法是否可中断

一般说来，如果一个方法声明抛出InterruptedException，表示该方法是可中断的,比如wait,sleep,join，也就是说可中断方法会对interrupt调用做出响应（例如sleep响应interrupt的操作包括清除中断状态，抛出InterruptedException）,异常都是由可中断方法自己抛出来的，并不是直接由interrupt方法直接引起的。

Object.wait, Thread.sleep方法，会不断的轮询监听 interrupted 标志位，发现其设置为true后，会停止阻塞并抛出 InterruptedException异常。