interrupt()方法

title:线程中断

date:2017年11月4日23:02:38


今天来看看线程中断的问题。

当一个线程运行时,另一个线程可以调用对应的Thread对象的interrupt()方法来中断它,该方法只是在目标线程中设置一个标志,表示它已经被中断,并立即返回。中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,就取决于这个程序本身。线程会不时地检测这个中断标示位,以判断线程是否应该被中断(中断标示值是否为true)。它并不像stop方法那样会中断一个正在运行的线程。

一.如何判断线程是否被中断

在Thread类的API中有三个和线程中断关系密切的方法,上面的interrupt()方法当然就是其中一个,还有两个则是用来判断线程是否中断。他们分别是

  • isInterrupted

    先看JDK API 文档的简单介绍。

    public boolean isInterrupted()
    测试线程是否已经中断。线程的中断状态 不受该方法的影响。 
    线程中断被忽略,因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。 
    返回:
    如果该线程已经中断,则返回 true;否则返回 false
  • interrupted

    public static boolean interrupted()
    

    测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说,如果连续两次调用该方法,则第二次调用将返回 false(在第一次调用已清除了其中断状态之后,且第二次调用检验完中断状态前,当前线程再次中断的情况除外)。
    线程中断被忽略,因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。

    返回:
    如果当前线程已经中断,则返回 true;否则返回 false。

    这里我们要注意,这是Thread的static方法,我们看看Thread的源码

      public static boolean interrupted() {
          return currentThread().isInterrupted(true);
      }
      private native boolean isInterrupted(boolean ClearInterrupted);
    public boolean isInterrupted() {
          return isInterrupted(false);
      }
    

    我们注意到interrupted()和isInterrupted()都是调用了本地方法isInterrupted(boolean ClearInterrupted);但是刚好他们的参数是相反的,这也就是API文档里说的,对于isInterrupted()线程的中断状态 不受该方法的影响。 而对于interrupted()线程的中断状态 由该方法清除。

    我们来写个测试程序来看看。

    package com.wangcc.thread.interrupt;
    
    public class InterruptReset {
    public static void main(String[] args) {
        System.out.println("Point X: Thread.interrupted()=" + Thread.interrupted());
        Thread.currentThread().interrupt();
        System.out.println("Point Y: Thread.interrupted()=" + Thread.interrupted());
        System.out.println("Point Z: Thread.interrupted()=" + Thread.interrupted());
        System.out.println("Point T: Thread.interrupted()=" + Thread.interrupted());
    
    }
    }
    

    我们查看结果:

    Point X: Thread.interrupted()=false
    Point Y: Thread.interrupted()=true
    Point Z: Thread.interrupted()=false
    Point T: Thread.interrupted()=false

    如果线程被中断,而且中断状态尚不清楚,那么,这个方法返回true。与isInterrupted()不同,它将自动重置中断状态为false,第二次调用Thread.interrupted()方法,总是返回false,除非中断了线程。不过目前为止,对于为什么这么设计还没有一丝头绪。

通过上述说明,我们先得出一个简单结论:

判断某个线程是否已被发送过中断请求,请使用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();//重新设置中断标示
        }
    }
}

注意之所以run方法进入时都要使用!Thread.currentThread().isInterrupted()轮询是把interrupt方法当做一个终止这个线程的请求,也就是相当于一个flag标志位。一定要理解这一点。

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

    package com.wangcc.MyJavaSE.thread.interrupt;
    
    /**
    * @ClassName: InterruptTest
    * @Description: 中断信号量中断线程
    * @author wangcc
    * @date 2017年11月11日 下午1:44:20
    * 
    */
    public class InterruptTest extends Thread {
    private volatile boolean stop = false;
    
    public static void main(String[] args) throws InterruptedException {
        InterruptTest test = new InterruptTest();
        System.out.println("Starting thread...");
    
        test.start();
        Thread.sleep(3000);
        System.out.println("Asking thread to stop...");
        test.stop = true;
        Thread.sleep(3000);
        System.out.println("Stopping application...");
    
    }
    
    public void run() {
        while (!stop) {
            System.out.println("Thread is running");
            long begin = System.currentTimeMillis();
            /**
             * 使用while循环模拟sleep方法,这里不要使用sleep,否则在阻塞时会抛InterruptedException异常而退出循环,
             * 这样while检测stop条件就不会执行,失去了意义。
             */
            while (System.currentTimeMillis() - begin > 1000) {
    
            }
        }
    }
    }
    

    注意,我们这里的stop标志位使用了volatile关键字来修饰,为什么这么修饰,我们会在后面说到这个关键字的时候详细介绍。

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

    package com.wangcc.MyJavaSE.thread.interrupt;
    
    public class InterruptTest1 extends Thread {
    
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        InterruptTest1 test = new InterruptTest1();
        System.out.println("Starting thread...");
    
        test.start();
        Thread.sleep(3000);
        System.out.println("Asking thread to stop...");
        test.interrupt();
        Thread.sleep(3000);
        System.out.println("Stopping application...");
    }
    
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Thread is running");
            long begin = System.currentTimeMillis();
            /**
             * 使用while循环模拟sleep方法,这里不要使用sleep,否则在阻塞时会抛InterruptedException异常而退出循环,
             * 这样while检测stop条件就不会执行,失去了意义。
             */
            // try {
            // Thread.sleep(1000);
            // } catch (InterruptedException e) {
            // // TODO Auto-generated catch block
            // e.printStackTrace();
            // }
            while (System.currentTimeMillis() - begin > 1000) {
    
            }
        }
    }
    }
    

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

三.总结

一、没有任何语言方面的需求一个被中断的线程应该终止。中断一个线程只是为了引起该线程的注意,被中断线程可以决定如何应对中断。

二、对于处于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()方法将资源关闭,对应的阻塞也会被放开。

 其实,Java的中断是一种协作机制。也就是说调用线程对象的interrupt方法并不一定就中断了正在运行的线程,它只是要求线程自己在合适的时机中断自己。每个线程都有一个boolean的中断状态(这个状态不在Thread的属性上),interrupt方法仅仅只是将该状态置为true。

比如对正常运行的线程调用interrupt()并不能终止他,只是改变了interrupt标示符。

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

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

你可能感兴趣的:(多线程系列)