对中断interrupt的理解

1、中断

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

线程的可运行状态并不表明线程必定在运行(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的区别与联系 

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

一、interrupt()方法
interrupt()方法用于中断线程。调用该方法的线程的状态为将被置为"中断"状态。
中断能够理解为线程的一个标识位属性，它表示一个运行中的线程是否被其余线程进行了中断操做。中断比如其余线程对该线程打了个招呼，其余线程经过调用该线程的interrupt()方法对其进行中断操做。
注意：线程中断仅仅是置线程的中断状态位，不会中止线程。须要用户本身去监视线程的状态为并作处理。

二、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中断线程的真正用途