线程不是你想中断就能中断

  • 为什么不强制停止
  • 如何用 interrupt 停止线程
  • sleep 期间能否感受到中断
  • 停止线程的方式有几种
  • 总结

启动线程需要调用 Thread 类的 start() 方法，并在 run() 方法中定义需要执行的任务。启动一个线程非常简单，但如果想要正确停止它就没那么容易了。

对于实现线程的几种方式，可见我的上一篇文章

实现线程本质上只有一种方式

为什么不强制停止

对于 Java 而言，最正确的停止线程的方式是使用 interrupt。但 interrupt仅仅起到通知被停止线程的作用。而对于被停止的线程而言，它拥有完全的自主权，它既可以选择立即停止，也可以选择一段时间后停止，也可以选择压根不停止。

为什么 Java 不提供强制停止线程的能力呢?事实上，Java 希望程序间能够相互通知、相互协作地管理线程，因为如果不了解对方正在做的工作，贸然强制停止线程就可能会造成一些安全的问题。

比如：线程正在写入一个文件，这时收到终止信号，它就需要根据自身业务判断，是选择立即停止，还是将整个文件写入成功后停止。如果选择立即停止就可能造成数据不完整，不管是中断命令发起者，还是接收者都不希望数据出现问题。

如何用 interrupt 停止线程

 
 
 
 
    
  
  
  
  
  1. while (!Thread.currentThread().isInterrupted() 
    2. 
  
  
  
  
  2. && more work to do) {
    3. 
  
  
  
  
  3.     do more work
    4. 
  
  
  
  
  4. }
    5.

我们一旦调用某个线程的 interrupt() 之后，这个线程的中断标记位就会被设置成true。每个线程都有这样的标记位，当线程执行时，应该定期检查这个标记位，如果标记位被设置成 true，就说明有程序想终止该线程。

回到源码，可以看到在 while 循环体判断语句中，首先通过

Thread.currentThread().isInterrupt()

判断线程是否被中断，随后检查是否还有工作要做。&& 逻辑表示只有当两个判断条件同时满足的情况下，才会去执行下面的工作。

 
 
 
 
    
  
  
  
  
  1. public class StopThread implements Runnable {
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     @Override
    4. 
  
  
  
  
  4.     public void run() {
    5. 
  
  
  
  
  5.         int count = 0;
    6. 
  
  
  
  
  6.         while (!Thread.currentThread().isInterrupted() && count < 1000) {
    7. 
  
  
  
  
  7.             System.out.println("count = " + count++);
    8. 
  
  
  
  
  8.         }
    9. 
  
  
  
  
  9.     }
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.     public static void main(String[] args) throws InterruptedException {
    12. 
  
  
  
  
  12.         Thread thread = new Thread(new StopThread());
    13. 
  
  
  
  
  13.         thread.start();
    14. 
  
  
  
  
  14.         Thread.sleep(5);
    15. 
  
  
  
  
  15.         thread.interrupt();
    16. 
  
  
  
  
  16.     }
    17. 
  
  
  
  
  17. }
    18.

在 StopThread 类的 run() 方法中，首先判断线程是否被中断，然后判断 count 值是否小于 1000。

这个线程的工作内容很简单，就是打印 0~999 的数字，每打印一个数字 count 值加 1，可以看到，线程会在每次循环开始之前，检查是否被中断了。接下来在 main 函数中会启动该线程，然后休眠 5 毫秒后立刻中断线程，该线程会检测到中断信号，于是在还没打印完1000个数的时候就会停下来，这种就属于通过 interrupt 正确停止线程的情况。

sleep 期间能否感受到中断

先说结论，可以。

 
 
 
 
    
  
  
  
  
  1. public class StopDuringSleep {
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     public static void main(String[] args) throws InterruptedException {
    4. 
  
  
  
  
  4.         Runnable runnable = () -> {
    5. 
  
  
  
  
  5.             int num = 0;
    6. 
  
  
  
  
  6.             try {
    7. 
  
  
  
  
  7.                 while (!Thread.currentThread().isInterrupted() && num <= 1000) {
    8. 
  
  
  
  
  8.                     System.out.println(num);
    9. 
  
  
  
  
  9.                     num++;
    10. 
  
  
  
  
  10.                     Thread.sleep(1000000);
    11. 
  
  
  
  
  11.                 }
    12. 
  
  
  
  
  12.             } catch (InterruptedException e) {
    13. 
  
  
  
  
  13.                 e.printStackTrace();
    14. 
  
  
  
  
  14.             }
    15. 
  
  
  
  
  15.         };
    16. 
  
  
  
  
  16.         Thread thread = new Thread(runnable);
    17. 
  
  
  
  
  17.         thread.start();
    18. 
  
  
  
  
  18.         Thread.sleep(5);
    19. 
  
  
  
  
  19.         thread.interrupt();
    20. 
  
  
  
  
  20.     }
    21. 
  
  
  
  
  21. }
    22.

运行后的结果你猜怎么着，程序会抛出异常

如果 sleep、wait 等可以让线程进入阻塞的方法使线程休眠了，而处于休眠中的线程被中断，那么线程是可以感受到中断信号的，并且会抛出一个 InterruptedException 异常，同时清除中断信号，将中断标记位设置成 false。这样一来就不用担心长时间休眠中线程感受不到中断了，因为即便线程还在休眠，仍然能够响应中断通知，并抛出异常。

但是这样只能相应一次中断信号了，怎么办?我的业务还没有完成收尾，怎么办?

合理利用好 try/catch

我们在实际开发中不能盲目吞掉中断，如果不在方法签名中声明，也不在 catch 语句块中再次恢复中断，而是在 catch 中不作处理，我们称这种行为是“屏蔽了中断请求”。如果我们盲目地屏蔽了中断请求，会导致中断信号被完全忽略，最终导致线程无法正确停止。

 
 
 
 
    
  
  
  
  
  1. try {
    2. 
  
  
  
  
  2.         Thread.sleep(2000);
    3. 
  
  
  
  
  3.     } catch (InterruptedException e) {
    4. 
  
  
  
  
  4. //        此处处理中断异常请求，业务收尾
    5. 
  
  
  
  
  5.     }
    6.

停止线程的方式有几种

 
 
 
 
    
  
  
  
  
  1. void shutdown;
    2. 
  
  
  
  
  2. boolean isShutdown;
    3. 
  
  
  
  
  3. boolean isTerminated;
    4. 
  
  
  
  
  4. boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
    5. 
  
  
  
  
  5. List shutdownNow;
    6.

下面我们就对这些方法逐一展开。

shutdown()

调用 shutdown() 方法之后线程池并不是立刻就被关闭，因为这时线程池中可能还有很多任务正在被执行，或是任务队列中有大量正在等待被执行的任务，调用 shutdown() 方法后线程池会在执行完正在执行的任务和队列中等待的任务后才彻底关闭。但这并不代表 shutdown() 操作是没有任何效果的，调用 shutdown() 方法后如果还有新的任务被提交，线程池则会根据拒绝策略直接拒绝后续新提交的任务。

isShutdown()

它可以返回 true 或者 false 来判断线程池是否已经开始了关闭工作，也就是是否执行了 shutdown 或者 shutdownNow 方法。这里需要注意，如果调用 isShutdown() 方法的返回的结果为 true 并不代表线程池此时已经彻底关闭了，这仅仅代表线程池开始了关闭的流程，也就是说，此时可能线程池中依然有线程在执行任务，队列里也可能有等待被执行的任务。

isTerminated()

这个方法可以检测线程池是否真正“终结”了，这不仅代表线程池已关闭，同时代表线程池中的所有任务都已经都执行完毕了，因为我们刚才说过，调用 shutdown 方法之后，线程池会继续执行里面未完成的任务，不仅包括线程正在执行的任务，还包括正在任务队列中等待的任务。比如此时已经调用了 shutdown 方法，但是有一个线程依然在执行任务，那么此时调用 isShutdown 方法返回的是 true ，而调用 isTerminated 方法返回的便是 false ，因为线程池中还有任务正在在被执行，线程池并没有真正“终结”。直到所有任务都执行完毕了，调用 isTerminated() 方法才会返回 true，这表示线程池已关闭并且线程池内部是空的，所有剩余的任务都执行完毕了。

awaitTermination()

第四个方法叫作 awaitTermination()，它本身并不是用来关闭线程池的，而是主要用来判断线程池状态的。比如我们给 awaitTermination 方法传入的参数是 10 秒，那么它就会陷入 10 秒钟的等待，直到发生以下三种情况之一：

  • 等待期间(包括进入等待状态之前)线程池已关闭并且所有已提交的任务(包括正在执行的和队列中等待的都执行完毕,相当于线程池已经“终结”了,方法便会返回true
  • 等待超时时间到后,第一种线程池“终结”的情况始终未发生,方法返回 false
  • 等待期间线程被中断,方法会抛出 Interruptedexception异常

等待期间(包括进入等待状态之前)线程池已关闭并且所有已提交的任务(包括正在执行的和队列中等待的)都执行完毕，相当于线程池已经“终结”了，方法便会返回 true;

等待超时时间到后，第一种线程池“终结”的情况始终未发生，方法返回 false;等待期间线程被中断，方法会抛出 InterruptedException 异常。

shutdownNow()

最后一个方法是 shutdownNow()，也是 5 种方法里功能最强大的，它与第一种 shutdown 方法不同之处在于名字中多了一个单词 Now，也就是表示立刻关闭的意思。在执行 shutdownNow 方法之后，首先会给所有线程池中的线程发送 interrupt 中断信号，尝试中断这些任务的执行，然后会将任务队列中正在等待的所有任务转移到一个 List 中并返回，我们可以根据返回的任务 List 来进行一些补救的操作，例如记录在案并在后期重试。

 
 
 
 
    
  
  
  
  
  1. public List shutdownNow() { 
    2. 
  
  
  
  
  2.     List tasks;
    3. 
  
  
  
  
  3.     final ReentrantLock mainLock = this.mainLock;
    4. 
  
  
  
  
  4.     mainLock.lock();
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.     try { 
    7. 
  
  
  
  
  7.         checkShutdownAccess();
    8. 
  
  
  
  
  8.         advanceRunState(STOP);
    9. 
  
  
  
  
  9.         interruptWorkers();
    10. 
  
  
  
  
  10.         tasks = drainQueue();
    11. 
  
  
  
  
  11.     } finally { 
    12. 
  
  
  
  
  12.         mainLock.unlock();
    13. 
  
  
  
  
  13.     } 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15.     tryTerminate();
    16. 
  
  
  
  
  16.     return tasks;
    17. 
  
  
  
  
  17.  }
    18.

源码中有一行 interruptWorkers() 代码，这行代码会让每一个已经启动的线程都中断，这样线程就可以在执行任务期间检测到中断信号并进行相应的处理，提前结束任务。这里需要注意的是，由于 Java 中不推荐强行停止线程的机制的限制，即便我们调用了 shutdownNow 方法，如果被中断的线程对于中断信号不理不睬，那么依然有可能导致任务不会停止。

总结

中断和关闭线程的方式五花八门，看起来很相似，其实里头大有门道。处理不好，可是会导致程序崩溃的。

本文题目：线程不是你想中断就能中断
文章出自：http://www.shufengxianlan.com/qtweb/news9/363309.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

虚拟主机知识

分类信息网

雅安服务器托管　　 　崇州湖霆科技　　 　亮美家　　 　汕尾凯敏网站　　 　成都商城网站建设　　 　网站建设公司　　 　企业网站改版　　 　温岭熙道网站　　 　网络推广外包　　 　买链接　　 　小谭网创广告　　 　百度推广公司　　 　合江网站建设　　 　响应式网站建设　　 　犀浦防纹窗　　 　成都免费自助建站　　 　泸州做网站　　 　企业营销型网站　　 　绵阳服务器托管　　 　响应式网站建设方案