关于java:面试官问如何中断一个线程具体如何实现

中断线程

线程的thread.interrupt()办法是中断线程，将会设置该线程的中断状态位，即设置为true，中断的后果线程是死亡、还是期待新的工作或是持续运行至下一步，就取决于这个程序自身。线程会不断地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。它并不像stop办法那样会中断一个正在运行的线程。

判断线程是否被中断

判断某个线程是否已被发送过中断请求，请应用Thread.currentThread().isInterrupted()办法（因为它将线程中断标示位设置为true后，不会立即革除中断标示位，即不会将中断标设置为false），而不要应用thread.interrupted()（该办法调用后会将中断标示位革除，即从新设置为false）办法来判断，上面是线程在循环中时的中断形式：

while(!Thread.currentThread().isInterrupted() && more work to do){
    do more work
}

如何中断线程

如果一个线程处于了阻塞状态（如线程调用了thread.sleep、thread.join、thread.wait、1.5中的condition.await、以及可中断的通道上的 I/O 操作方法后可进入阻塞状态），则在线程在查看中断标示时如果发现中断标示为true，则会在这些阻塞办法（sleep、join、wait、1.5中的condition.await及可中断的通道上的 I/O 操作方法）调用处抛出InterruptedException异样，并且在抛出异样后立刻将线程的中断标示位革除，即从新设置为false。抛出异样是为了线程从阻塞状态醒过来，并在完结线程前让程序员有足够的工夫来解决中断请求。

注，synchronized在获锁的过程中是不能被中断的，意思是说如果产生了死锁，则不可能被中断（请参考前面的测试例子）。与synchronized性能类似的reentrantLock.lock()办法也是一样，它也不可中断的，即如果产生死锁，那么reentrantLock.lock()办法无奈终止，如果调用时被阻塞，则它始终阻塞到它获取到锁为止。然而如果调用带超时的tryLock办法reentrantLock.tryLock(long timeout, TimeUnit unit)，那么如果线程在期待时被中断，将抛出一个InterruptedException异样，这是一个十分有用的个性，因为它容许程序突破死锁。你也能够调用reentrantLock.lockInterruptibly()办法，它就相当于一个超时设为有限的tryLock办法。

没有任何语言方面的需要一个被中断的线程应该终止。中断一个线程只是为了引起该线程的留神，被中断线程能够决定如何应答中断。某些线程十分重要，以至于它们应该不理睬中断，而是在解决完抛出的异样之后继续执行，然而更广泛的状况是，一个线程将把中断看作一个终止申请，这种线程的run办法遵循如下模式：

public void run() {
    try {
        ...
        /*
         * 不论循环里是否调用过线程阻塞的办法如sleep、join、wait，这里还是须要加上
         * !Thread.currentThread().isInterrupted()条件，尽管抛出异样后退出了循环，显
         * 得用阻塞的状况下是多余的，但如果调用了阻塞办法但没有阻塞时，这样会更平安、更及时。
         */
        while (!Thread.currentThread().isInterrupted()&& more work to do) {
            do more work
        }
    } catch (InterruptedException e) {
        //线程在wait或sleep期间被中断了
    } finally {
        //线程完结前做一些清理工作
    }
}

下面是while循环在try块里，如果try在while循环里时，因该在catch块里从新设置一下中断标示，因为抛出InterruptedException异样后，中断标示位会主动革除，此时应该这样：

public void run() {
    while (!Thread.currentThread().isInterrupted()&& more work to do) {
        try {
            ...
            sleep(delay);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();//从新设置中断标示
        }
    }
}

底层中断异样解决形式

另外不要在你的底层代码里捕捉InterruptedException异样后不解决，会处理不当，如下：

void mySubTask(){
    ...
    try{
        sleep(delay);
    }catch(InterruptedException e){}//不要这样做
    ...
}

如果你不晓得抛InterruptedException异样后如何解决，那么你有如下好的倡议解决形式：

1、在catch子句中，调用Thread.currentThread.interrupt()来设置中断状态（因为抛出异样后中断标示会被革除），让外界通过判断Thread.currentThread().isInterrupted()标示来决定是否终止线程还是继续下去，应该这样做：

void mySubTask() {
    ...
    try {
        sleep(delay);
    } catch (InterruptedException e) {
        Thread.currentThread().isInterrupted();
    }
    ...
}

2、或者，更好的做法就是，不应用try来捕捉这样的异样，让办法间接抛出：

void mySubTask() throws InterruptedException {
    ...
    sleep(delay);
    ...
}

中断利用

应用中断信号量中断非阻塞状态的线程

中断线程最好的，最受举荐的形式是，应用共享变量（shared variable）发出信号，通知线程必须进行正在运行的工作。线程必须周期性的核查这一变量，而后有秩序地停止工作。Example2形容了这一形式：

class Example2 extends Thread {
    volatile boolean stop = false;// 线程中断信号量

    public static void main(String args[]) throws Exception {
        Example2 thread = new Example2();
        System.out.println("Starting thread...");
        thread.start();
        Thread.sleep(3000);
        System.out.println("Asking thread to stop...");
        // 设置中断信号量
        thread.stop = true;
        Thread.sleep(3000);
        System.out.println("Stopping application...");
    }

    public void run() {
        // 每隔一秒检测一下中断信号量
        while (!stop) {
            System.out.println("Thread is running...");
            long time = System.currentTimeMillis();
            /*
             * 应用while循环模仿 sleep 办法，这里不要应用sleep，否则在阻塞时会 抛
             * InterruptedException异样而退出循环，这样while检测stop条件就不会执行，
             * 失去了意义。
             */
            while ((System.currentTimeMillis() - time < 1000)) {}
        }
        System.out.println("Thread exiting under request...");
    }
}

应用thread.interrupt()中断非阻塞状态线程

尽管Example2该办法要求一些编码，但并不难实现。同时，它给予线程机会进行必要的清理工作。这里需注意一点的是需将共享变量定义成volatile 类型或将对它的所有拜访封入同步的块/办法（synchronized blocks/methods）中。下面是中断一个非阻塞状态的线程的常见做法，但对非检测isInterrupted()条件会更简洁:

class Example2 extends Thread {
    public static void main(String args[]) throws Exception {
        Example2 thread = new Example2();
        System.out.println("Starting thread...");
        thread.start();
        Thread.sleep(3000);
        System.out.println("Asking thread to stop...");
        // 收回中断请求
        thread.interrupt();
        Thread.sleep(3000);
        System.out.println("Stopping application...");
    }

    public void run() {
        // 每隔一秒检测是否设置了中断标示
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Thread is running...");
            long time = System.currentTimeMillis();
            // 应用while循环模仿 sleep
            while ((System.currentTimeMillis() - time < 1000) ) {
            }
        }
        System.out.println("Thread exiting under request...");
    }
}

到目前为止一切顺利！然而，当线程期待某些事件产生而被阻塞，又会产生什么？当然，如果线程被阻塞，它便不能核查共享变量，也就不能进行。这在许多状况下会产生，例如调用Object.wait()、ServerSocket.accept()和DatagramSocket.receive()时，这里仅举出一些。

他们都可能永恒的阻塞线程。即便产生超时，在超时期满之前继续期待也是不可行和不适当的，所以，要应用某种机制使得线程更早地退出被阻塞的状态。上面就来看一下中断阻塞线程技术。

应用thread.interrupt()中断阻塞状态线程

Thread.interrupt()办法不会中断一个正在运行的线程。这一办法实际上实现的是，设置线程的中断标示位，在线程受到阻塞的中央（如调用sleep、wait、join等中央）抛出一个异样InterruptedException，并且中断状态也将被革除，这样线程就得以退出阻塞的状态。上面是具体实现：

class Example3 extends Thread {
    public static void main(String args[]) throws Exception {
        Example3 thread = new Example3();
        System.out.println("Starting thread...");
        thread.start();
        Thread.sleep(3000);
        System.out.println("Asking thread to stop...");
        thread.interrupt();// 等中断信号量设置后再调用
        Thread.sleep(3000);
        System.out.println("Stopping application...");
    }

    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Thread running...");
            try {
                /*
                 * 如果线程阻塞，将不会去查看中断信号量stop变量，所 以thread.interrupt()
                 * 会使阻塞线程从阻塞的中央抛出异样，让阻塞线程从阻塞状态逃离进去，并
                 * 进行异样块进行 相应的解决
                 */
                Thread.sleep(1000);// 线程阻塞，如果线程收到中断操作信号将抛出异样
            } catch (InterruptedException e) {
                System.out.println("Thread interrupted...");
                /*
                 * 如果线程在调用 Object.wait()办法，或者该类的 join() 、sleep()办法
                 * 过程中碰壁，则其中断状态将被革除
                 */
                System.out.println(this.isInterrupted());// false

                //中不中断由本人决定，如果须要真真中断线程，则须要从新设置中断位，如果
                //不须要，则不必调用
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("Thread exiting under request...");
    }
}

一旦Example3中的Thread.interrupt()被调用，线程便收到一个异样，于是逃离了阻塞状态并确定应该进行。下面咱们还能够应用共享信号量来替换!Thread.currentThread().isInterrupted()条件，但不如它简洁。

死锁状态线程无奈被中断

Example4试着去中断处于死锁状态的两个线程，但这两个线都没有收到任何中断信号（抛出异样），所以interrupt()办法是不能中断死锁线程的，因为锁定的地位根本无法抛出异样：

class Example4 extends Thread {
    public static void main(String args[]) throws Exception {
        final Object lock1 = new Object();
        final Object lock2 = new Object();
        Thread thread1 = new Thread() {
            public void run() {
                deathLock(lock1, lock2);
            }
        };
        Thread thread2 = new Thread() {
            public void run() {
                // 留神，这里在替换了一下地位
                deathLock(lock2, lock1);
            }
        };
        System.out.println("Starting thread...");
        thread1.start();
        thread2.start();
        Thread.sleep(3000);
        System.out.println("Interrupting thread...");
        thread1.interrupt();
        thread2.interrupt();
        Thread.sleep(3000);
        System.out.println("Stopping application...");
    }

    static void deathLock(Object lock1, Object lock2) {
        try {
            synchronized (lock1) {
                Thread.sleep(10);// 不会在这里死掉
                synchronized (lock2) {// 会锁在这里，尽管阻塞了，但不会抛异样
                    System.out.println(Thread.currentThread());
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
}

中断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()将不起作用，因为线程将不会退出被阻塞状态。Example5形容了这一行为。只管interrupt()被调用，线程也不会退出被阻塞状态，比方ServerSocket的accept办法基本不抛出异样。

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

class Example6 extends Thread {
    volatile ServerSocket socket;

    public static void main(String args[]) throws Exception {
        Example6 thread = new Example6();
        System.out.println("Starting thread...");
        thread.start();
        Thread.sleep(3000);
        System.out.println("Asking thread to stop...");
        Thread.currentThread().interrupt();// 再调用interrupt办法
        thread.socket.close();// 再调用close办法
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
        }
        System.out.println("Stopping application...");
    }

    public void run() {
        try {
            socket = new ServerSocket(8888);
        } catch (IOException e) {
            System.out.println("Could not create the socket...");
            return;
        }
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Waiting for connection...");
            try {
                socket.accept();
            } catch (IOException e) {
                System.out.println("accept() failed or interrupted...");
                Thread.currentThread().interrupt();//从新设置中断标示位
            }
        }
        System.out.println("Thread exiting under request...");
    }
}

一、没有任何语言方面的需要一个被中断的线程应该终止。中断一个线程只是为了引起该线程的留神，被中断线程能够决定如何应答中断。

二、对于处于sleep，join等操作的线程，如果被调用interrupt()后，会抛出InterruptedException，而后线程的中断标记位会由true重置为false，因为线程为了解决异样曾经从新处于就绪状态。

三、不可中断的操作，包含进入synchronized段以及Lock.lock()，inputSteam.read()等，调用interrupt()对于这几个问题有效，因为它们都不抛出中断异样。如果拿不到资源，它们会无限期阻塞上来。

对于Lock.lock()，能够改用Lock.lockInterruptibly()，可被中断的加锁操作，它能够抛出中断异样。等同于等待时间有限长的Lock.tryLock(long time, TimeUnit unit)。

对于inputStream等资源，有些(实现了interruptibleChannel接口)能够通过close()办法将资源敞开，对应的阻塞也会被放开。

首先，看看Thread类里的几个办法：

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

其实，Java的中断是一种合作机制。也就是说调用线程对象的interrupt办法并不一定就中断了正在运行的线程，它只是要求线程本人在适合的机会中断本人。每个线程都有一个boolean的中断状态（这个状态不在Thread的属性上），interrupt办法仅仅只是将该状态置为true。

比方对失常运行的线程调用interrupt()并不能终止他，只是扭转了interrupt标示符。

一般说来，如果一个办法申明抛出InterruptedException，示意该办法是可中断的,比方wait,sleep,join，也就是说可中断办法会对interrupt调用做出响应（例如sleep响应interrupt的操作包含革除中断状态，抛出InterruptedException）,异样都是由可中断办法本人抛出来的，并不是间接由interrupt办法间接引起的。

Object.wait, Thread.sleep办法，会一直的轮询监听 interrupted 标记位，发现其设置为true后，会进行阻塞并抛出 InterruptedException异样。

看了以上的阐明，对java中断的应用必定是会了，但我想晓得的是阻塞了的线程是如何通过interuppt办法实现进行阻塞并抛出interruptedException的，这就要看Thread中native的interuppt0办法了。

第一步学习Java的JNI调用Native办法。

第二步下载openjdk的源代码，找到目录构造里的openjdk-src\jdk\src\share\native\java\lang\Thread.c文件。

#include "jni.h"
#include "jvm.h"

#include "java_lang_Thread.h"

#define THD "Ljava/lang/Thread;"
#define OBJ "Ljava/lang/Object;"
#define STE "Ljava/lang/StackTraceElement;"

#define ARRAY_LENGTH(a) (sizeof(a)/sizeof(a[0]))

static JNINativeMethod methods[] = {
    {"start0",           "()V",        (void *)&JVM_StartThread},
    {"stop0",            "(" OBJ ")V", (void *)&JVM_StopThread},
    {"isAlive",          "()Z",        (void *)&JVM_IsThreadAlive},
    {"suspend0",         "()V",        (void *)&JVM_SuspendThread},
    {"resume0",          "()V",        (void *)&JVM_ResumeThread},
    {"setPriority0",     "(I)V",       (void *)&JVM_SetThreadPriority},
    {"yield",            "()V",        (void *)&JVM_Yield},
    {"sleep",            "(J)V",       (void *)&JVM_Sleep},
    {"currentThread",    "()" THD,     (void *)&JVM_CurrentThread},
    {"countStackFrames", "()I",        (void *)&JVM_CountStackFrames},
    {"interrupt0",       "()V",        (void *)&JVM_Interrupt},
    {"isInterrupted",    "(Z)Z",       (void *)&JVM_IsInterrupted},
    {"holdsLock",        "(" OBJ ")Z", (void *)&JVM_HoldsLock},
    {"getThreads",        "()[" THD,   (void *)&JVM_GetAllThreads},
    {"dumpThreads",      "([" THD ")[[" STE, (void *)&JVM_DumpThreads},
};

#undef THD
#undef OBJ
#undef STE
JNIEXPORT void JNICALL
Java_java_lang_Thread_registerNatives(JNIEnv *env, jclass cls)
{
    (*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));
}

作者：零_壹\
起源：https://blog.csdn.net/xinxiao…

近期热文举荐：

1.1,000+ 道 Java面试题及答案整顿(2022最新版)

2.劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4.20w 程序员红包封面，快快支付。。。

5.《Java开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞+转发哦！

关于java:面试官问如何中断一个线程具体如何实现

中断线程

判断线程是否被中断

如何中断线程

底层中断异样解决形式

中断利用

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于java:面试官问如何中断一个线程具体如何实现

中断线程

判断线程是否被中断

如何中断线程

底层中断异样解决形式

中断利用

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复