JAVA多线程之中断机制(如何处理中断？)

曾经终败给现在 2022-04-04 06:18 223阅读 0赞

转载自：[https://www.cnblogs.com/hapjin/p/5450779.html][https_www.cnblogs.com_hapjin_p_5450779.html]

## **介绍** ##

这篇文章主要记录使用 interrupt() 方法中断线程，以及如何对InterruptedException进行处理。感觉对InterruptedException异常进行处理是一件谨慎且有技巧的活儿。

由于使用stop()方法停止线程非常的暴力，人家线程运行的好好的，突然就把人家杀死了，线程占用的锁被强制释放，极易导致数据的不一致性。可参考[这篇文章][Link 1]对stop()方法的介绍。

因此，提出了一种温和的方式：请求另外一个线程不要再执行了，这就是中断方式。

## 中断的原理 ##

Java 中断机制是一种协作机制，也就是说通过中断并不能直接终止另一个线程，而需要被中断的线程自己处理中断。

Java 中断模型也是这么简单，每个线程对象里都有一个 boolean 类型的标识，代表着是否有中断请求（该请求可以来自所有线程，包括被中断的线程本身）。例如，当线程 t1 想中断线程 t2，只需要在线程 t1 中将线程 t2 对象的中断标识置为 true，然后线程 t2 可以选择在合适的时候处理该中断请求，甚至可以不理会该请求，就像这个线程没有被中断一样。

java.lang.Thread 类提供了几个方法来操作这个中断状态，这些方法包括：

<table> 
 <tbody> 
 <tr> 
 <td> public static boolean&nbsp;interrupted </td> 
 <td> 测试当前线程是否已经中断。线程的中断状态&nbsp;由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。 </td> 
 </tr> 
 <tr> 
 <td> public boolean&nbsp;isInterrupted() </td> 
 <td> 测试线程是否已经中断。线程的中断状态不受该方法的影响。 </td> 
 </tr> 
 <tr> 
 <td> public void&nbsp;interrupt() </td> 
 <td> 中断线程，将中断状态设置为true。 </td> 
 </tr> 
 </tbody> 
</table>

## **中断及如何响应中断？** ##

如何优雅地响应中断真的是太高深了，看到这篇文章：[Java 理论与实践: 处理 InterruptedException][Java _ _ InterruptedException]就吓了一跳。下面只是记录一些最简单的我对响应中断的理解。

假设某个线程要不停地处理某件事情(比如 i 一直自增)，但是还有个要求：在处理事情前，先要检查下这个线程是否被中断，如果已经被中断，处理就应该结束。

下面是一些例子：

public class Run {
    
        public static void main(String[] args) {
            try {
                MyThread thread = new MyThread();
                thread.start();
                Thread.sleep(20);//modify 2000 to 20
                thread.interrupt();//请求中断MyThread线程
            } catch (InterruptedException e) {
                System.out.println("main catch");
                e.printStackTrace();
            }
            System.out.println("end!");
        }
    }

main线程睡眠20ms后，执行第8行中断MyThread线程。

public class MyThread extends Thread {
 @Override
 public void run() {
 super.run();
 for (int i = 0; i < 500000; i++) {
 if (this.interrupted()) {
 System.out.println("should be stopped and exit");
 break;
 }
 System.out.println("i=" + (i + 1));
 }
 System.out.println("this line is also executed. thread does not stopped");//尽管线程被中断,但并没有结束运行。这行代码还是会被执行
 }
 }

当MyThread获得CPU执行时，第6行的 if 测试中，检测到中断标识被设置。即MyThread线程检测到了main线程想要中断它的 请求。

大多数情况下，MyThread检测到了中断请求，**对该中断的响应是：退出执行（或者说是结束执行）。**

但是，上面第5至8行for循环，是执行break语句跳出for循环。但是，线程并没有结束，它只是跳出了for循环而已，它还会继续执行第12行的代码....

**因此，我们的问题是，当收到了中断请求后，如何结束该线程呢？**

一种可行的方法是使用 return 语句 而不是 break语句。。。。。哈哈。。。

**当然，一种更优雅的方式则是：抛出InterruptedException异常。**

看下面MyThread类的代码：

public class MyThread extends Thread {
 @Override
 public void run() {
 super.run();
 try{
 for (int i = 0; i < 500000; i++) {
 if (this.interrupted()) {
 System.out.println("should be stopped and exit");
 throw new InterruptedException();
 }
 System.out.println("i=" + (i + 1));
 }
 System.out.println("this line cannot be executed. cause thread throws exception");//这行语句不会被执行!!!
 }catch(InterruptedException e){
 System.out.println("catch interrupted exception");
 e.printStackTrace();
 }
 }
 }

当MyThread线程检测到中断标识为true后，在第9行抛出InterruptedException异常。这样，该线程就不能再执行其他的正常语句了(如，第13行语句不会执行)。**这里表明：interrupt()方法有两个作用，一个是将线程的中断状态置位(中断状态由false变成true)；另一个则是：让被中断的线程抛出InterruptedException异常。**

*这是很重要的。这样，对于那些阻塞方法(比如 wait() 和 sleep())而言，当另一个线程调用interrupt()中断该线程时，该线程会从阻塞状态退出并且抛出中断异常。这样，我们就可以捕捉到中断异常，并根据实际情况对该线程从阻塞方法中异常退出而进行一些处理。*

*比如说：线程A获得了锁进入了同步代码块中，但由于条件不足调用 wait() 方法阻塞了。这个时候，线程B执行 threadA.interrupt()请求中断线程A，此时线程A就会抛出InterruptedException，我们就可以在catch中捕获到这个异常并进行相应处理(比如进一步往上抛出)*

因此，上面就是一个采用抛出异常的方式来结束线程的示例。尽管该示例的实用性不大。原因在 IBM的[这篇博文][Java _ _ InterruptedException]中：我们 生吞了中断。

在第14行，我们直接catch了异常，然后打印输出了一下而已，调用栈中的更高层的代码是无法获得关于该异常的信息的。

第16行的e.printStackTrace()作用就相当于

> “（仅仅记录 InterruptedException 也不是明智的做法，因为等到人来读取日志的时候，再来对它作出处理就为时已晚了。）”---摘自参考博文

上面我们是在run()方法中抛出异常，符合这里描述的：

> 有时候抛出 InterruptedException 并不合适，例如当由 Runnable 定义的任务调用一个  
> 可中断的方法时，就是如此。在这种情况下，不能重新抛出 InterruptedException，但是  
> 您也不想什么都不做。当一个阻塞方法检测到中断并抛出 InterruptedException 时，它  
> 清除中断状态。如果捕捉到 InterruptedException 但是不能重新抛出它，那么应该保留  
> 中断发生的证据，以便调用栈中更高层的代码能知道中断，并对中断作出响应。该任务可以  
> 通过调用 interrupt() 以 “重新中断” 当前线程来完成，如清单 3 所示。 -----“摘自参考博文”

因为，run方法是实现的Runnable接口中的方法。不能像下面这样定义，也即上面所说的：“不能重新抛出InterruptedException”。

@Override
            public void run() throws InterruptedException{//这是错误的
              //do something...

因此，一个更好的解决方案是：调用 `interrupt()` 以 “重新中断” 当前线程。改进MyThread类中catch异常的方式，如下：

public class MyThread extends Thread {
 @Override
 public void run() {
 super.run();
 try{
 for (int i = 0; i < 500000; i++) {
 if (this.interrupted()) {
 System.out.println("should be stopped and exit");
 throw new InterruptedException();
 }
 System.out.println("i=" + (i + 1));
 }
 System.out.println("this line cannot be executed. cause thread throws exception");
 }catch(InterruptedException e){
 /**这样处理不好
 * System.out.println("catch interrupted exception");
 * e.printStackTrace();
 */
 Thread.currentThread().interrupt();//这样处理比较好
 }
 }
 }

这样，就由 生吞异常 变成了 将 异常事件 进一步扩散了。

### 不可取消的任务 ###

有些任务拒绝被中断，这使得它们是不可取消的。但是，即使是不可取消的任务也应该尝试保留中断状态，以防在不可取消的任务结束之后，调用栈上更高层的代码需要对中断进行处理。以下代码展示了一个方法，该方法等待一个阻塞队列，直到队列中出现一个可用项目，而不管它是否被中断。为了方便他人，它在结束后在一个 finally 块中恢复中断状态，以免剥夺中断请求的调用者的权利。

public Task getNextTask(BlockingQueue<Task> queue) {
 
     boolean interrupted = false;
 
     try {
         while (true) {
             try {
                 return queue.take();
             } catch (InterruptedException e) {
                 interrupted = true;
                 // fall through and retry
             }
         }
     } finally {
         if (interrupted)
             Thread.currentThread().interrupt();
     }
 
 }

### 如何安全的终止线程 ###

安全的终止线程，除了中断外，还可以利用一个boolean变量来控制是否需要停止任务并终止线程。

class CanCancelThread extends Thread {
    
        private long i;
        private volatile boolean on = true;
    
        @Override
        public void run() {
            while (on && !Thread.currentThread().isInterrupted()) {
                i++;
            }
            System.out.println("Count i=" + i);
        }
    
        public void cancel() {
            on = false;
        }
    }

可以通过标识位或者中断的方式都能够是线程终止时有机会去清理资源，因此这种方式显得更加优雅和安全。

[参考博文：Java 理论与实践: 处理 InterruptedException][Java _ _ InterruptedException]

[详细分析Java中断机制][Java]

参考书籍：《Java多线程编程核心技术》

[https_www.cnblogs.com_hapjin_p_5450779.html]: https://www.cnblogs.com/hapjin/p/5450779.html
[Link 1]: http://www.cnblogs.com/hapjin/p/5450121.html
[Java _ _ InterruptedException]: http://www.ibm.com/developerworks/cn/java/j-jtp05236.html
[Java]: http://www.infoq.com/cn/articles/java-interrupt-mechanism