Java 中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。

    ● void interrupt（）方法 ：中断线程，例如，当线程 A 运行时，线程 B 可以调用线程 A 的 interrupt（）方法来设置线程 A 的中断标志为 true 并立即返回。设置标志仅仅是设置标志，线程 A 实际并没有被中断，它会继续往下执行。如果线程 A 因为调用了 wait 系列函数、join 方法或者 sleep 方法而被阻塞挂起，这时候若线程 B 调用线程 A 的 interrupt（）方法，线程 A 会在调用这些方法的地方抛出 InterruptedException 异常而返回。

    ● boolean isInterrupted（）方法：检测当前线程是否被中断，如果是返回 true，否则返回 false。

    1. public boolean isInterrupted() {
    2.       //传递 false，说明不清除中断标志 
    3.       return isInterrupted（false）；
    4.   }

    ● boolean interrupted（）方法：检测当前线程是否被中断，如果是返回 true，否则返回 false。与 isInterrupted 不同的是，该方法如果发现当前线程被中断，则会清除中断标志，并且该方法是 static 方法，可以通过 Thread 类直接调用。另外从下面的代码可以知道，在 interrupted（）内部是获取当前调用线程的中断标志而不是调用 interrupted（）方法的实例对象的中断标志。

    1. public static boolean interrupted() {
    2.   //清除中断标志 
    3.   return currentThread().isInterrupted（true）；
    4. }

    下面看一个线程使用 Interrupted 优雅退出的经典例子，代码如下。

    1. public void run(){
    2.     try{
    3.         ....
    4.         //线程退出条件 
    5.         while（! Thread.currentThread().isInterrupted()&& more work to do）{
    6.                 // do more work；
    7.         }
    8.     }catch（InterruptedException e）{
    9.                 // thread was interrupted during sleep or wait
    10.     }
    11.     finally{
    12.               // cleanup， if required
    13.     }
    14. }

    下面看一个根据中断标志判断线程是否终止的例子。

    1. public static void main（String[] args） throws InterruptedException {
    2.     Thread thread = new Thread(new Runnable() {
    3.         @Override
    4.         public void run() {
    5.             //如果当前线程被中断则退出循环 
    6.             while (！ Thread.currentThread().isInterrupted())
    7.                 System.out.println(Thread.currentThread() + 「 hello」)；
    8.         }
    9.     })；
    10.     //启动子线程 
    11.     thread.start()；
    12.     //主线程休眠 1s，以便中断前让子线程输出 
    13.     Thread.sleep(1000)；
    14.     //中断子线程 
    15.     System.out.println（「main thread interrupt thread」）；
    16.     thread.interrupt()；
    17.     //等待子线程执行完毕 
    18.     thread.join()；
    19.     System.out.println（「main is over」）；
    20. }

    输出结果如下．

    线程中断 - 图1

    在如上代码中，子线程 thread 通过检查当前线程中断标志来控制是否退出循环，主线程在休眠 1s 后调用 thread 的 interrupt（）方法设置了中断标志，所以线程 thread 退出了循环。

    下面再来看一种情况。当线程为了等待一些特定条件的到来时，一般会调用 sleep 函数、wait 系列函数或者 join（）函数来阻塞挂起当前线程。比如一个线程调用了 Thread. sleep（3000），那么调用线程会被阻塞，直到 3s 后才会从阻塞状态变为激活状态。但是有可能在 3s 内条件已被满足，如果一直等到 3s 后再返回有点浪费时间，这时候可以调用该线程的 interrupt（）方法，强制 sleep 方法抛出 InterruptedException 异常而返回，线程恢复到激活状态。下面看一个例子。

    1. public static void main（String[] args） throws InterruptedException {
    2.       Thread threadOne = new Thread(new Runnable() {
    3.           public void run() {
    4.               try {
    5.                   System.out.println（「threadOne begin sleep for 2000 seconds」）；
    6.                   Thread.sleep(2000000)；
    7.                   System.out.println（「threadOne awaking」）；
    8.               } catch （InterruptedException e） {
    9.                   System.out.println（「threadOne is interrupted while sleeping」）；
    10.                   return；
    11.               }
    12.               System.out.println（「threadOne-leaving normally」）；
    13.           }
    14.       })；
    15.       //启动线程 
    16.       threadOne.start()；
    17.       //确保子线程进入休眠状态 
    18.       Thread.sleep(1000)；
    19.       //打断子线程的休眠，让子线程从 sleep 函数返回 
    20.       threadOne.interrupt()；
    21.       //等待子线程执行完毕 
    22.       threadOne.join()；
    23.       System.out.println（「main thread is over」）；
    24. }

    输出结果如下。

    线程中断 - 图2

    在如上代码中，threadOne 线程休眠了 2000s，在正常情况下该线程需要等到 2000s 后才会被唤醒，但是本例通过调用 threadOne.interrupt（）方法打断了该线程的休眠，该线程会在调用 sleep 方法处抛出 InterruptedException 异常后返回。

    下面再通过一个例子来了解 interrupted（）与 isInterrupted（）方法的不同之处。

    1. public static void main（String[] args） throws InterruptedException {
    2.     Thread threadOne = new Thread（new Runnable() {
    3.         public void run() {
    4.               for(; ; ){
    5.               }
    6.         }
    7.     }）；
    8.     //启动线程 
    9.     threadOne.start()；
    10.     //设置中断标志 
    11.     threadOne.interrupt()；
    12.     //获取中断标志 
    13.     System.out.println(「isInterrupted:」 + threadOne.isInterrupted())；
    14.     //获取中断标志并重置 
    15.     System.out.println(「isInterrupted:」 + threadOne.interrupted())；
    16.     //获取中断标志并重置 
    17.     System.out.println(「isInterrupted:」 + Thread.interrupted())；
    18.     //获取中断标志 
    19.     System.out.println(「isInterrupted:」 + threadOne.isInterrupted())；
    20.     threadOne.join()；
    21.     System.out.println("main thread is over");
    22. }

    输出结果如下。

    线程中断 - 图3

    第一行输出 true 这个大家应该都可以想到，但是下面三行为何是 false、false、true 呢，不应该是 true、false、false 吗？如果你有这个疑问，则说明你对这两个函数的区别还是不太清楚。上面我们介绍了在 interrupted（）方法内部是获取当前线程的中断状态，这里虽然调用了 threadOne 的 interrupted（）方法，但是获取的是主线程的中断标志，因为主线程是当前线程。threadOne.interrupted（）和 Thread.interrupted（）方法的作用是一样的，目的都是获取当前线程的中断标志。修改上面的例子为如下。

    1. public static void main（String[] args） throws InterruptedException {
    2.     Thread threadOne = new Thread(new Runnable() {
    3.         public void run() {
    4.             //中断标志为 true 时会退出循环，并且清除中断标志 
    5.             while (！ Thread.currentThread().interrupted()) {
    6.             }
    7.             System.out.println(「threadOne isInterrupted:」 + Thread.currentThread().
    8. isInterrupted())；
    9.         }
    10.     })；
    11.     // 启动线程 
    12.     threadOne.start()；
    13.     // 设置中断标志 
    14.     threadOne.interrupt()；
    15.     threadOne.join()；
    16.     System.out.println（「main thread is over」）；
    17. }

    输出结果如下。

    线程中断 - 图4

    由输出结果可知，调用 interrupted（）方法后中断标志被清除了。