对中断interrupt的理解

Posted zeroingToOne

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了对中断interrupt的理解相关的知识,希望对你有一定的参考价值。

一、中断

线程的几种状态:新建、就绪、运行、阻塞、死亡。参考:线程的几种状态转换 

线程的可运行状态并不代表线程一定在运行(runnable != running ) 。 大家都知道:所有现代桌面和服务器操作系统都使用了抢占式的线程调度策略 。一旦线程开始执行,并不是总是保持持续运行状态的。当系统分给它的时间片(非常小的运行时间单位)用完以后,不管程序有没有执行完,线程被强制放弃CPU,进入就绪状态,直到下次被调度后开始继续执行。也就是说, Runnable可运行状态的线程处于两种可能的情况下:(1)占用CPU运行中,(2)等待调度的就绪状态。 这里要声明一下:处于等待调度的就绪状态线程和处于阻塞的线程是完全不同的。就绪的线程是因为时间片用完而放弃CPU,其随时都有可能再次获得CPU而运行,这一切取决于分时OS的线程调度策略。

在很多操作系统的专业术语中,这种因时间片用完而被剥夺CPU的情况我们叫做线程中断 。注意这和我们下面要将得中断线程是两个完全不同的概念。事实上,我们不可能通过应用程序来控制CPU的线程中断,除非我们能够自由调用OS的内核。
中断可以理解为线程的一个标识位属性,表示一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了一个招呼,其他线程通过调用该线程的interrupt()方法对其进行中断操作。

一个正在运行的线程除了正常的时间片中断之外,能否被其他线程控制?或者说其他线程能否让指定线程放弃CPU或者提前结束运行? 除了线程同步机制之外,还有两种方法:
(1) stop(), suspend(), resume() 和Runtime.runFinalizersOnExit() ,但这些方法已经被废弃。
(2) interrupt() 方法

例:创建了一个线程countThread,它不断地进行变量累加,而主线程尝试对其进行中断操作和停止操作。

import java.util.concurrent.TimeUnit;

public class Shutdown {
    public static void main(String[] args) throws Exception {
        Runner one = new Runner();
        Thread countThread = new Thread(one, "CountThread");
        countThread.start();
        // 睡眠1秒,main线程对CountThread进行中断,使CountThread能够感知中断而结束
        TimeUnit.SECONDS.sleep(1); //Thread.sleep(1000);
        countThread.interrupt();
        System.out.println("是否停止1:" + countThread.isInterrupted());
        Runner two = new Runner();
        countThread = new Thread(two, "CountThread");
        countThread.start();
        // 睡眠1秒,main线程对Runner two进行取消,使CountThread能够感知on为false而结束
        TimeUnit.SECONDS.sleep(1);
        two.cancel();
        System.out.println("是否停止2:" + countThread.isInterrupted());
    }

    private static class Runner implements Runnable {
        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;
        }
    }
}

运行结果:

是否停止1:true
Count i = 574867187
是否停止2:false
Count i = 581254533

main线程通过中断操作和cancel()方法均可使线程countThread终止。
当我们调用countThread.interrput()的时候,线程countThread的中断状态(interrupted status) 会被置位。我们可以通过Thread.currentThread().isInterrupted() 来检查这个布尔型的中断状态。

在Core Java中有这样一句话:"没有任何语言方面的需求要求一个被中断的程序应该终止。中断一个线程只是为了引起该线程的注意,被中断线程可以决定如何应对中断 "。

while循环有一个决定因素就是需要不停的检查自己的中断状态。当外部线程调用该线程的interrupt 时,使得中断状态置位。这时该线程将终止循环,不再执行循环中的内容。

这说明: interrupt中断的是线程的某一部分业务逻辑,前提是线程需要检查自己的中断状态(isInterrupted())。

参考:

java线程之中断线程Interrupted用法 

《Java并发编程的艺术》

另:Thread.sleep和TimeUnit.SECONDS.sleep的区别与联系 

二、interrupt()、interrupted() 和 isInterrupted()方法的区别

1、interrupt()方法
interrupt()方法用于中断线程。调用该方法的线程的状态为将被置为"中断"状态。
中断可以理解为线程的一个标识位属性,它表示一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了个招呼,其他线程通过调用该线程的interrupt()方法对其进行中断操作。
注意:线程中断仅仅是置线程的中断状态位,不会停止线程。需要用户自己去监视线程的状态为并做处理。

2、interrupted() 和 isInterrupted()

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

public boolean isInterrupted() {
    return isInterrupted(false);
}

private native boolean isInterrupted(boolean ClearInterrupted);

从源代码可以看出:
interrupted()测试的是当前线程(current thread)的中断状态,且这个方法会清除中断状态。是静态方法(它测试的是当前线程的中断状态)
isInterrupted()测试的是调用该方法的对象所表示的线程,且这个方法不会清除中断状态。是实例方法(它测试的是实例对象所表示的线程的中断状态)

关于方法isInterrupted( boolean ClearInterrupted):
通过参数名ClearInterrupted可以知道,这个参数代表是否要清除状态位。
如果这个参数为true,说明返回线程的状态位后,要清掉原来的状态位(恢复成原来情况)。这个参数为false,就是直接返回线程的状态位。

这两个方法很好区分,只有当前线程才能清除自己的中断位(对应interrupted()方法)

例:1. interrupted()方法

 1 public class InterruptedTest {
 2     public static void main(String[] args) throws InterruptedException {
 3         MyThread thread = new MyThread();
 4         thread.start();
 5         Thread.sleep(1000);
 6 
 7         System.out.println("当前正在执行的线程:" + Thread.currentThread().getName());
 8 
 9         thread.interrupt(); // Thread.currentThread().interrupt();
10 
11         System.out.println("是否停止?=" + thread.interrupted());// false,main线程没有被中断
12     }
13 }
14 
15 class MyThread extends Thread {
16     @Override
17     public void run() {
18         int i = 0;
19         super.run();
20         for (; i < 500000; i++) {
21             i++;
22         }
23         System.out.println("i: " + i);
24     }
25 }

运行结果:

i: 500000
当前正在执行的线程:main
是否停止?=false

第4行启动thread线程,第5行使main线程睡眠1秒钟从而使得thread线程有机会获得CPU执行。
main线程睡眠1s钟后,恢复执行到第7行,请求中断 thread线程。
第11行测试线程是否处于中断状态,这里测试的是哪个线程呢?答案是main线程。因为:

(1)interrupted()测试的是当前的线程的中断状态

(2)main线程执行了第11行语句,故main线程是当前线程

如果将第9行换成Thread.currentThread().interrupt();,则运行结果为:

i: 500000
当前正在执行的线程:main
是否停止?=true

2. isInterrupted()方法

 1 public class InterruptedTest {
 2     public static void main(String[] args) throws InterruptedException {
 3         MyThread thread = new MyThread();
 4         thread.start();
 5         //Thread.sleep(1000);
 6 
 7         System.out.println("当前正在执行的线程:" + Thread.currentThread().getName());
 8 
 9         thread.interrupt(); 
10 
11         System.out.println("是否停止?=" + thread.isInterrupted());// false,main线程没有被中断
12     }
13 }
14 
15 class MyThread extends Thread {
16     @Override
17     public void run() {
18         int i = 0;
19         super.run();
20         for (; i < 500000; i++) {
21             i++;
22         }
23         System.out.println("i: " + i);
24     }
25 }

运行结果:

当前正在执行的线程:main
是否停止?=true
i: 500000

在第11行,是thread对象调用的isInterrupted()方法。因此,测试的是thread对象所代表的线程的中断状态。由于在第9行,main线程请求中断 thread线程,故在第11行的结果为: true

 

另外:当线程被阻塞的时候,比如被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞时。调用它的interrput()方法。可想而知,没有占用CPU运行的线程是不可能给自己的中断状态置位的。这就会产生一个InterruptedException异常。例:

public class InterruptedSleep {
    public static void main(String[] args) {
        Runnable tr = new TestRunnable();
        Thread th1 = new Thread(tr);
        th1.start(); // 开始执行分线程
        while (true) {
            th1.interrupt(); // 中断这个分线程
        }
    }
}

class TestRunnable implements Runnable {
    public void run() {
        try {
            Thread.sleep(1000000); // 这个线程将被阻塞1000秒
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("是否停止:" + Thread.currentThread().isInterrupted());
        }
    }
}

运行结果:

java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at threadArt.TestRunnable.run(InterruptedSleep.java:17)
    at java.lang.Thread.run(Thread.java:745)
是否停止:true

因此:

要中断一个Java线程,可调用线程类(Thread)对象的实例方法:interrupte();然而interrupte()方法并不会立即执行中断操作;具体而言,这个方法只会给线程设置一个为true的中断标志(中断标志只是一个布尔类型的变量),而设置之后,则根据线程当前的状态进行不同的后续操作

1. 如果线程的当前状态处于非阻塞状态,那么仅仅是线程的中断标志被修改为true而已

2. 如果线程的当前状态处于阻塞状态,那么在将中断标志设置为true后,还会有如下三种情况之一的操作:

(1) 如果是wait、sleep以及jion三个方法引起的阻塞,那么会将线程的中断标志重新设置为false,并抛出一个InterruptedException
(2) 如果是java.nio.channels.InterruptibleChannel进行的io操作引起的阻塞,则会对线程抛出一个ClosedByInterruptedException;(待验证)
(3) 如果是轮询(java.nio.channels.Selectors)引起的线程阻塞,则立即返回,不会抛出异常。(待验证)
如果在中断时,线程正处于非阻塞状态,则将中断标志修改为true,而在此基础上,一旦进入阻塞状态,则按照阻塞状态的情况来进行处理;例如,一个线程在运行状态中,其中断标志被设置为true,则此后,一旦线程调用了wait、jion、sleep方法中的一种,立马抛出一个InterruptedException,且中断标志被清除,重新设置为false
通过上面的分析,我们可以总结,调用线程类的interrupted方法,其本质只是设置该线程的中断标志,将中断标志设置为true,并根据线程状态决定是否抛出异常。因此,通过interrupted方法真正实现线程的中断原理是:开发人员根据中断标志的具体值,来决定如何退出线程。

参考:
JAVA多线程之中断机制(stop()、interrupted()、isInterrupted())
使用interrupte中断线程的真正用途 

以上是关于对中断interrupt的理解的主要内容,如果未能解决你的问题,请参考以下文章

Thread类的interrupt方法

Java线程专题 4:线程停止

Java线程专题 4:线程停止

interrupt()中断对LockSupport.park()行为影响

JVM 对 interrupt 信号的响应

详解线程interrupt()方法