本文转自http://jiangzhengjun.iteye.com/blog/652269
中断线程
线程的thread.interrupt()方法是中断线程，将会设置该线程为中断状态，即设置为true。线程中断后的结果是死亡、还是等待新的任务或是继续运行至下一步，取决于这个程序本身。线程会不时地检测这个中断标识位，以判断线程是否应该被中断（中断标识值是否为true）。它并不像stop方法那样会中断一个正在运行的线程。
判断线程是否被中断
判断某个线程是否已被中断，
请使用Thread.currentThread().isInterrupted()方法（因为它将线程中断标识位设置为true后，不会立刻清除中断标识位，即不会将中断标设置为false），
而不要使用thread.interrupted()（该方法调用后会将中断标标位清除，即重新设置为false）方法来判断，下面是线程在循环中时的中断方式：
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方法遵循如下形式
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异常后，中断标示位会自动清除，此时应该这样：
while ( ! Thread.currentThread().isInterrupted() && more work to do ) {
try {
...
sleep(delay);
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 重新设置中断标示
}
}
}
底层中断异常处理方式
另外不要在你的底层代码里捕获InterruptedException异常后不处理，会处理不当，如下：
...
try {
sleep(delay);
} catch (InterruptedException e){} // 不要这样做
...
}
如果你不知道抛InterruptedException异常后如何处理，那么你有如下好的建议处理方式：
1、在catch子句中，调用Thread.currentThread.interrupt()来设置中断状态（因为抛出异常后中断标示会被清除），让外界通过判断Thread.currentThread().isInterrupted()标示来决定是否终止线程还是继续下去，应该这样做：
...
try {
sleep(delay);
} catch (InterruptedException e) {
Thread.currentThread().interrupted();
}
...
}
2、或者，更好的做法就是，不使用try来捕获这样的异常，让方法直接抛出
...
sleep(delay);
...
}
中断应用
使用中断信号量中断非阻塞状态的线程
中断线程最好的，最受推荐的方式是，使用共享变量（shared variable）发出信号，告诉线程必须停止正在运行的任务。线程必须周期性的核查这一变量，然后有秩序地中止任务
public class ThreadTest extends Thread{
// 线程中断信号量
volatile boolean stop = false ;
public static void main(String[] args) throws Exception {
ThreadTest thread = new ThreadTest();
System.out.println( " Starting thread... " );
thread.start();
Thread.sleep( 3000 );
System.out.println( " Asking thread to stop... " );
// 设置中断信号量
thread.stop = true ;
Thread.sleep( 3000 );
System.out.println( " Stopping application... " );
}
@Override
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 )) {
}
}
System.out.println( " Thread exiting under request! " );
}
}
运行结果如下：
使用thread.interrupt()中断非阻塞状态线程
虽然上面案例要求一些编码，但并不难实现。同时，它给予线程机会进行必要的清理工作。这里需注意一点的是需将共享变量定义成volatile 类型或将对它的一切访问封入同步的块/方法（synchronized blocks/methods）中。上面是中断一个非阻塞状态的线程的常见做法，但对非检测isInterrupted()条件会更简洁:
public class ThreadTest extends Thread{
public static void main(String[] args) throws Exception {
ThreadTest thread = new ThreadTest();
System.out.println( " Starting thread... " );
thread.start();
Thread.sleep( 3000 );
System.out.println( " Asking thread to stop... " );
// 发出中断请求
thread.interrupt();
Thread.sleep( 3000 );
System.out.println( " Stopping application... " );
}
@Override
public void run() {
// 每隔一秒检测一下中断信号量
while ( ! Thread.currentThread().isInterrupted()){
System.out.println( " Thread is running! " );
long begin = System.currentTimeMillis();
/**
* 使用while循环模拟sleep方法，这里不要使用sleep，否则在阻塞时会抛InterruptedException异常而退出循环，
* 这样while检测stop条件就不会执行，失去了意义。
*/
while ((System.currentTimeMillis() - begin < 1000 )) {
}
}
System.out.println( " Thread exiting under request! " );
}
}
到目前为止一切顺利！但是，当线程等待某些事件发生而被阻塞，又会发生什么？当然，如果线程被阻塞，它便不能核查共享变量，也就不能停止。这在许多情况下会发生，例如调用Object.wait()、ServerSocket.accept()和DatagramSocket.receive()时，这里仅举出一些。
他们都可能永久的阻塞线程。即使发生超时，在超时期满之前持续等待也是不可行和不适当的，所以，要使用某种机制使得线程更早地退出被阻塞的状态。下面就来看一下中断阻塞线程技术。
使用thread.interrupt()中断阻塞状态线程
Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是，设置线程的中断标示位，在线程受到阻塞的地方（如调用sleep、wait、join等地方）抛出一个异常InterruptedException，并且中断状态也将被清除，这样线程就得以退出阻塞的状态。下面是具体实现：
public class ThreadTest extends Thread{
public static void main(String[] args) throws Exception {
ThreadTest thread = new ThreadTest();
System.out.println( " Starting thread... " );
thread.start();
Thread.sleep( 3000 );
thread.interrupt(); // 等中断信号量设置后再调用
System.out.println( " Asking thread to stop... " );
Thread.sleep( 3000 );
System.out.println( " Stopping application... " );
}
@Override
public void run() {
while ( ! Thread.currentThread().isInterrupted()){
System.out.println( " Thread running... " );
try {
/**
* 如果线程阻塞，将不会去检查中断信号量stop变量，所以thread.interrupt()
* 会使阻塞线程从阻塞的地方抛出异常，让阻塞线程从阻塞状态逃离出来，并进行异常块进行相应的处理
*/
Thread.sleep( 1000 ); // 线程阻塞，如果线程收到中断操作信号将抛出异常
} catch (InterruptedException e) {
System.out.println( " Thread interrupted... " );
/**
* 如果线程在调用Object.wait()方法，或者该类的join()、sleep()方法
* 过程中受阻，则其中断状态将被清除
*/
System.out.println( this .isInterrupted()); // false
// 中不中断由自己决定，如果需要中断线程，则需要重新设置中断位，如果不需要，则不用调用
Thread.currentThread().interrupt();
e.printStackTrace();
}
}
System.out.println( " Thread exiting under request... " );
}
}
上面案例中一旦Thread.interrupt()被调用，线程便收到一个异常，于是逃离了阻塞状态并确定应该停止。上面我们还可以使用共享信号量来替换!Thread.currentThread().isInterrupted()条件，但不如它简洁.
死锁状态线程无法被中断
下面案例中试着去中断处于死锁状态的两个线程，但这两个线都没有收到任何中断信号（抛出异常），所以interrupt()方法是不能中断死锁线程的，因为锁定的位置根本无法抛出异常
public class ThreadTest extends Thread {
public static void main(String args[]) throws Exception {
final Object lock1 = new Object();
final Object lock2 = new Object();
Thread thread1 = new Thread() {
public void run() {
deathLock(lock1, lock2);
}
};
Thread thread2 = new Thread() {
public void run() {
// 注意，这里在交换了一下位置
deathLock(lock2, lock1);
}
};
System.out.println( " Starting thread... " );
thread1.start();
thread2.start();
Thread.sleep( 3000 );
System.out.println( " Interrupting thread... " );
thread1.interrupt();
thread2.interrupt();
Thread.sleep( 3000 );
System.out.println( " Stopping application... " );
}
private static void deathLock(Object lock1, Object lock2) {
try {
synchronized (lock1) {
Thread.sleep( 10 ); // 不会在这里死掉
synchronized (lock2) { // 会锁在这里，虽然阻塞了，但不会抛异常
System.out.println(Thread.currentThread());
}
}
} catch (InterruptedException e) {
e.printStackTrace();
System.exit( 1 );
}
}
}
中断I/O操作
然而，如果线程在I/O操作进行时被阻塞，又会如何？I/O操作可以阻塞线程一段相当长的时间，特别是牵扯到网络应用时。例如，服务器可能需要等待一个请求（request），又或者，一个网络应用程序可能要等待远端主机的响应。
实现此InterruptibleChannel接口的通道是可中断的：如果某个线程在可中断通道上因调用某个阻塞的 I/O 操作（常见的操作一般有这些：serverSocketChannel. accept()、socketChannel.connect、socketChannel.open、socketChannel.read、socketChannel.write、fileChannel.read、fileChannel.write）而进入阻塞状态，而另一个线程又调用了该阻塞线程的 interrupt 方法，这将导致该通道被关闭，并且已阻塞线程接将会收到ClosedByInterruptException，并且设置已阻塞线程的中断状态。另外，如果已设置某个线程的中断状态并且它在通道上调用某个阻塞的 I/O 操作，则该通道将关闭并且该线程立即接收到 ClosedByInterruptException；并仍然设置其中断状态。如果情况是这样，其代码的逻辑和第三个例子中的是一样的，只是异常不同而已。
如果你正使用通道（channels）（这是在Java 1.4中引入的新的I/O API），那么被阻塞的线程将收到一个ClosedByInterruptException异常。但是，你可能正使用Java1.0之前就存在的传统的I/O，而且要求更多的工作。既然这样，Thread.interrupt()将不起作用，因为线程将不会退出被阻塞状态。尽管interrupt()被调用，线程也不会退出被阻塞状态，比如ServerSocket的accept方法根本不抛出异常。
很幸运，Java平台为这种情形提供了一项解决方案，即调用阻塞该线程的套接字的close()方法。在这种情形下，如果线程被I/O操作阻塞，当调用该套接字的close方法时，该线程在调用accept地方法将接收到一个SocketException（SocketException为IOException的子异常）异常，这与使用interrupt()方法引起一个InterruptedException异常被抛出非常相似，（注，如果是流因读写阻塞后，调用流的close方法也会被阻塞，根本不能调用，更不会抛IOExcepiton，此种情况下怎样中断？我想可以转换为通道来操作流可以解决，比如文件通道）。下面是具体实现：
import java.io.IOException;
import java.net.ServerSocket;
public class ThreadTest extends Thread {
volatile ServerSocket socket;
public static void main(String args[]) throws Exception {
ThreadTest thread = new ThreadTest();
System.out.println( " Starting thread... " );
thread.start();
Thread.sleep( 3000 );
System.out.println( " Asking thread to stop... " );
Thread.currentThread().interrupt(); // 再调用interrupt方法
thread.socket.close(); // 再调用close方法，此句去掉将发生阻塞状态
try {
Thread.sleep( 3000 );
} catch (InterruptedException e) {
}
System.out.println( " Stopping application... " );
}
public void run() {
try {
socket = new ServerSocket( 3036 );
} catch (IOException e) {
System.out.println( " Could not create the socket... " );
return ;
}
while ( ! Thread.currentThread().isInterrupted()) {
System.out.println( " Waiting for connection... " );
try {
socket.accept();
} catch (IOException e) {
System.out.println( " accept() failed or interrupted... " );
Thread.currentThread().interrupt(); // 重新设置中断标示位
}
}
// 判断线程是否被阻塞，如果被阻塞则无法打印此句
System.out.println( " Thread exiting under request... " );
}
}