本文主要探讨一下中断线程的几种方式。

通过一个变量控制线程中断

代码：
package com.itsoku.chat05;

import java.util.concurrent.TimeUnit;

/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo1** {

  1. **public** **volatile** **static** **boolean** exit = **false**;
  3. **public** **static** **class** **T** **extends** **Thread** {<br />        @Override<br />        **public** **void** **run**() {<br />            **while** (**true**) {<br />                //循环处理业务<br />                **if** (exit) {<br />                    **break**;<br />                }<br />            }<br />        }<br />    }
  5. **public** **static** **void** **setExit**() {<br />        exit = **true**;<br />    }
  7. **public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        T t = **new** T();<br />        t.start();<br />        TimeUnit.SECONDS.sleep(3);<br />        setExit();<br />    }<br />}

代码中启动了一个线程，线程的 run 方法中有个死循环，内部通过 exit 变量的值来控制是否退出。TimeUnit.SECONDS.sleep(3);让主线程休眠 3 秒，此处为什么使用 TimeUnit？TimeUnit 使用更方便一些，能够很清晰的控制休眠时间，底层还是转换为 Thread.sleep 实现的。程序有个重点：volatile关键字，exit 变量必须通过这个修饰，如果把这个去掉，程序无法正常退出。volatile 控制了变量在多线程中的可见性，关于 volatile 前面的文章中有介绍，此处就不再说了。

通过线程自带的中断标志控制

示例代码：
package com.itsoku.chat05;

import java.util.concurrent.TimeUnit;

/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo2** {

  1. **public** **static** **class** **T** **extends** **Thread** {<br />        @Override<br />        **public** **void** **run**() {<br />            **while** (**true**) {<br />                //循环处理业务<br />                **if** (**this**.isInterrupted()) {<br />                    **break**;<br />                }<br />            }<br />        }<br />    }
  3. **public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        T t = **new** T();<br />        t.start();<br />        TimeUnit.SECONDS.sleep(3);<br />        t.interrupt();<br />    }<br />}

运行上面的程序，程序可以正常结束。线程内部有个中断标志，当调用线程的 interrupt()实例方法之后，线程的中断标志会被置为 true，可以通过线程的实例方法 isInterrupted()获取线程的中断标志。

线程阻塞状态中如何中断

示例代码：
package com.itsoku.chat05;

import java.util.concurrent.TimeUnit;

/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo3** {

  1. **public** **static** **class** **T** **extends** **Thread** {<br />        @Override<br />        **public** **void** **run**() {<br />            **while** (**true**) {<br />                //循环处理业务<br />                //下面模拟阻塞代码<br />                **try** {<br />                    TimeUnit.SECONDS.sleep(1000);<br />                } **catch** (InterruptedException e) {<br />                    e.printStackTrace();<br />                }<br />            }<br />        }<br />    }
  3. **public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        T t = **new** T();<br />        t.start();<br />    }<br />}

运行上面代码，发现程序无法结束。
在此先补充几点知识：

  1. 调用线程的 interrupt()实例方法，线程的中断标志会被置为 true
  2. 当线程处于阻塞状态时，调用线程的 interrupt()实例方法，线程内部会触发 InterruptedException 异常，并且会清除线程内部的中断标志（即将中断标志置为 false）

那么上面代码可以调用线程的 interrupt()方法来引发 InterruptedException 异常，来中断 sleep 方法导致的阻塞，调整一下代码，如下：
package com.itsoku.chat05;

import java.util.concurrent.TimeUnit;

/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo3** {

  1. **public** **static** **class** **T** **extends** **Thread** {<br />        @Override<br />        **public** **void** **run**() {<br />            **while** (**true**) {<br />                //循环处理业务<br />                //下面模拟阻塞代码<br />                **try** {<br />                    TimeUnit.SECONDS.sleep(1000);<br />                } **catch** (InterruptedException e) {<br />                    e.printStackTrace();<br />                    **this**.interrupt();<br />                }<br />                **if** (**this**.isInterrupted()) {<br />                    **break**;<br />                }<br />            }<br />        }<br />    }
  3. **public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        T t = **new** T();<br />        t.start();<br />        TimeUnit.SECONDS.sleep(3);<br />        t.interrupt();<br />    }<br />}

运行结果：
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at java.lang.Thread.sleep(Thread.java:340)
at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
at com.itsoku.chat05.Demo3$T.run(Demo3.java:17)

程序可以正常结束了，分析一下上面代码，注意几点：

  1. main 方法中调用了 t.interrupt()方法，此时线程 t 内部的中断标志会置为 true
  2. 然后会触发 run()方法内部的 InterruptedException 异常，所以运行结果中有异常输出，上面说了，当触发 InterruptedException 异常时候，线程内部的中断标志又会被清除（变为 false），所以在 catch 中又调用了 this.interrupt();一次，将中断标志置为 false

  3. run()方法中通过 this.isInterrupted()来获取线程的中断标志，退出循环（break）

    总结

  4. 当一个线程处于被阻塞状态或者试图执行一个阻塞操作时，可以使用Thread.interrupt()方式中断该线程，注意此时将会抛出一个InterruptedException的异常，同时中断状态将会被复位(由中断状态改为非中断状态)

  5. 内部有循环体，可以通过一个变量来作为一个信号控制线程是否中断，注意变量需要 volatile 修饰
  6. 文中的几种方式可以结合起来灵活使用控制线程的中断