中断线程
线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。它并不像stop方法那样会中断一个正在运行的线程。
判断线程是否被中断
判断某个线程是否已被发送过中断请求，请使用Thread.currentThread().isInterrupted()方法（因为它将线程中断标示位设置为true后，不会立刻清除中断标示位，即不会将中断标设置为false），而不要使用thread.interrupted()（该方法调用后会将中断标示位清除，即重新设置为false）方法来判断，下面是线程在循环中时的中断方式：
while(!Thread.currentThread().isInterrupted() && more work to do){
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方法遵循如下形式：
1 public void run() {
2 try {
3 ...
4 /*
5 * 不管循环里是否调用过线程阻塞的方法如sleep、join、wait，这里还是需要加上
6 * !Thread.currentThread().isInterrupted()条件，虽然抛出异常后退出了循环，显
7 * 得用阻塞的情况下是多余的，但如果调用了阻塞方法但没有阻塞时，这样会更安全、更及时。
8 */
9 while (!Thread.currentThread().isInterrupted()&& more work to do) {
10 do more work
11 }
12 } catch (InterruptedException e) {
13 //线程在wait或sleep期间被中断了，检查到中断标示值为true，这时就会抛出InterruptedException,从阻塞状态醒过来
14 } finally {
15 //线程结束前做一些清理工作
16 }
17 }
上面是while循环在try块里，如果try在while循环里时，因该在catch块里重新设置一下中断标示，因为抛出InterruptedException异常后，中断标示位会自动清除，此时应该这样：
1 public void run() {
2 while (!Thread.currentThread().isInterrupted()&& more work to do) {
3 try {
4 ...
5 sleep(delay);
6 } catch (InterruptedException e) {
7 Thread.currentThread().interrupt();//重新设置中断标示
8 }
9 }
10 }
底层中断异常处理方式
另外不要在你的底层代码里捕获InterruptedException异常后不处理，会处理不当，如下：
void mySubTask(){
...
try{
sleep(delay);
}catch(InterruptedException e){}//不要这样做
...
}
如果你不知道抛InterruptedException异常后如何处理，那么你有如下好的建议处理方式：
1、在catch子句中，调用Thread.currentThread.interrupt()来设置中断状态（因为抛出异常后中断标示会被清除），让外界通过判断Thread.currentThread().isInterrupted()标示来决定是否终止线程还是继续下去，应该这样做：
void mySubTask() {
...
try {
sleep(delay);
} catch (InterruptedException e) {
Thread.currentThread().isInterrupted();
}
...
}
2、或者，更好的做法就是，不使用try来捕获这样的异常，让方法直接抛出：
void mySubTask() throws InterruptedException {
...
sleep(delay);
...
}
中断应用
使用中断信号量中断非阻塞状态的线程
中断线程最好的，最受推荐的方式是，使用共享变量（shared variable）发出信号，告诉线程必须停止正在运行的任务。线程必须周期性的核查这一变量，然后有秩序地中止任务。Example2描述了这一方式：
1 public class Example1 {
2 volatile static boolean stop = false;//中断信号量
3 static class MyThread extends Thread{
4 public void run(){
5 while(!stop){//每隔一秒检查一次中断信号量
6 System.out.println("thread is running...");
7 long time = System.currentTimeMillis();
8 while (System.currentTimeMillis()-time<1000){}
9 //使用while循环模拟sleep(),这里不要使用sleep，否则在阻塞时会
10 // 抛InterruptedException异常而退出循环，这样while检测stop条件就不会执行，失去了意义。
11 }
12 System.out.println("thread is stoped1");
13 }
14 }
15 public static void main(String args[]) throws InterruptedException{
16 MyThread thread = new MyThread();
17 System.out.println("Starting thread...");
18 thread.start();
19 Thread.sleep(3500);
20 System.out.println("stoping thread...");
21 stop = true;
22 Thread.sleep(3000);
23 System.out.println("thread is stoped2");
24 }
25 }
使用thread.interrupt()中断非阻塞状态线程
虽然Example1该方法要求一些编码，但并不难实现。同时，它给予线程机会进行必要的清理工作。这里需注意一点的是需将共享变量定义成volatile 类型或将对它的一切访问封入同步的块/方法（synchronized blocks/methods）中。上面是中断一个非阻塞状态的线程的常见做法，但对非检测isInterrupted()条件会更简洁:
1 public class Example1 {
2 public static void main(String args[]) throws InterruptedException {
3 MyThread thread = new MyThread();
4 System.out.println("Starting thread...");
5 thread.start();
6 Thread.sleep(3500);
7 System.out.println("stoping thread...");
8 thread.interrupt();//中断线程
9 Thread.sleep(3000);
10 System.out.println("thread is stoped2");
11 }
12
13 static class MyThread extends Thread {
14 public void run() {
15 while (!Thread.currentThread().isInterrupted()) {//判断某个线程是否已被发送过中断请求
16 System.out.println("thread is running...");
17 long time = System.currentTimeMillis();
18 while (System.currentTimeMillis() - time < 1000) {
19 }
20 //使用while循环模拟sleep(),这里不要使用sleep，否则在阻塞时会
21 // 抛InterruptedException异常而退出循环，这样while检测stop条件就不会执行，失去了意义。
22 }
23 System.out.println("thread is stoped1");
24 }
25 }
26 }
现在考虑另外一个情况。
如果线程被阻塞，它便不能核查中断标识位，也就不能停止。这在许多情况下会发生，例如调用Object.wait()、Thread.sleep()、ServerSocket.accept()和DatagramSocket.receive()时，这里仅举出一些。他们都可能永久的阻塞线程。即使发生超时，在超时期满之前持续等待也是不可行和不适当的，所以，要使用某种机制使得线程更早地退出被阻塞的状态。下面就来看一下中断阻塞线程技术。
使用thread.interrupt()中断阻塞状态线程
Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是，设置线程的中断标示位，在线程受到阻塞的地方（如调用sleep、wait、join等地方）抛出一个异常InterruptedException，并且中断状态也将被清除，这样线程就得以退出阻塞的状态。下面是具体实现：
1 //中断阻塞进程
2 public class Example2 {
3 static class MyThread extends Thread{
4 public void run(){
5 while (!Thread.currentThread().isInterrupted()){
6 try{
7 /*
8 * 如果线程阻塞，将不会去检查中断标识位，所 以thread.interrupt()
9 * 会使阻塞线程从阻塞的地方抛出异常，让阻塞线程从阻塞状态逃离出来，并
10 * 进行异常块进行 相应的处理
11 */
12 System.out.println("thread is ready to sleep...");
13 Thread.sleep(2000);// 线程阻塞，如果线程收到中断操作信号将抛出异常
14 }
15 catch (InterruptedException e){
16 System.out.println("thread is interrupted.");
17 /*
18 * 如果线程在调用 Object.wait()方法，或者该类的 join() 、sleep()方法
19 * 过程中被中断，那么就会被抛出InterruptedException，然后它的中断状态将被复位，即其中断状态将被清除
20 */
21 System.out.println(Thread.currentThread().isInterrupted());//false
22 Thread.currentThread().interrupt();//中不中断由自己决定，如果需要真的中断线程，则需要重新设置中断位，如果不需要，则不用调用
23 //若这里没有Thread.currentThread().interrupt();那么线程就会一直在执行，while循环
24 }
25 }
26 System.out.println("Thread exiting under request...");
27 }
28 }
29 public static void main(String args[]) throws InterruptedException{
30 MyThread thread = new MyThread();
31 System.out.println("starting thread...");
32 thread.start();
33 Thread.sleep(3000);
34 System.out.println("Asking thread to stop...");
35 thread.interrupt();
36 Thread.sleep(3000);
37 System.out.println("Stopping application...");
38 }
39 }
一旦Example2中的Thread.interrupt()被调用，线程便收到一个异常，于是逃离了阻塞状态并确定应该停止。上面我们还可以使用共享信号量来替换!Thread.currentThread().isInterrupted()条件。
1 /*
2 * 如果线程被阻塞，它便不能核查共享变量，也就不能停止。这在许多情况下会发生，例如调用
3 * Object.wait()、ServerSocket.accept()和DatagramSocket.receive()时，他们都可能永
4 * 久的阻塞线程。即使发生超时，在超时期满之前持续等待也是不可行和不适当的，所以，要使
5 * 用某种机制使得线程更早地退出被阻塞的状态。很不幸运，不存在这样一种机制对所有的情况
6 * 都适用，但是，根据情况不同却可以使用特定的技术。使用Thread.interrupt()中断线程正
7 * 如Example1中所描述的，Thread.interrupt()方法不会中断一个正在运行的线程。这一方法
8 * 实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更
9 * 确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，
10 * 它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。因此，
11 * 如果线程被上述几种方法阻塞，正确的停止线程方式是设置共享变量，并调用interrupt()（注
12 * 意变量应该先设置）。如果线程没有被阻塞，这时调用interrupt()将不起作用；否则，线程就
13 * 将得到异常（该线程必须事先预备好处理此状况），接着逃离阻塞状态。在任何一种情况中，最
14 * 后线程都将检查共享变量然后再停止。下面示例描述了该技术。
15 * */
16 public class Example3 {
17 volatile static boolean stop = false;
18 static class MyThread extends Thread {
19 public void run() {
20 while (!stop) {
21 System.out.println("Thread running...");
22 try {
23 Thread.sleep(2000);
24 } catch (InterruptedException e) {
25 // 接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态
26 System.out.println("Thread interrupted...");
27 }
28 }
29
30 System.out.println("Thread exiting under request...");
31 }
32 }
33
34 public static void main(String args[]) throws Exception {
35 MyThread thread = new MyThread();
36 System.out.println("Starting thread...");
37 thread.start();
38 Thread.sleep(3000);
39 System.out.println("Asking thread to stop...");
40 /*
41 * 如果线程阻塞，将不会检查此变量,调用interrupt之后，线程就可以尽早的终结被阻
42 * 塞状 态，能够检查这一变量。
43 * */
44 stop = true;
45
46 /*
47 * 这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退
48 * 出阻 塞的状态
49 * */
50 //thread.interrupt();
51
52 Thread.sleep(3000);
53 System.out.println("Stopping application...");
54 System.exit(0);
55 }
56 }
57 /*
58 * 把握几个重点：stop变量、run方法中的sleep()、interrupt()、InterruptedException。串接起
59 * 来就是这个意思：当我们在run方法中调用sleep（或其他阻塞线程的方法）时，如果线程阻塞的
60 * 时间过长，比如10s，那在这10s内，线程阻塞，run方法不被执行，但是如果在这10s内，stop被
61 * 设置成true，表明要终止这个线程，但是，现在线程是阻塞的，它的run方法不能执行，自然也就
62 * 不能检查stop，所 以线程不能终止，这个时候，我们就可以用interrupt()方法了：我们在
63 * thread.stop = true;语句后调用thread.interrupt()方法， 该方法将在线程阻塞时抛出一个中断
64 * 信号，该信号将被catch语句捕获到，一旦捕获到这个信号，线程就提前终结自己的阻塞状态，这
65 * 样，它就能够 再次运行run 方法了，然后检查到stop = true，while循环就不会再被执行，在执
66 * 行了while后面的清理工作之后，run方法执行完 毕，线程终止。
67 * */
死锁状态线程无法被中断
Example4试着去中断处于死锁状态的两个线程，但这两个线都没有收到任何中断信号（抛出异常），所以interrupt()方法是不能中断死锁线程的，因为锁定的位置根本无法抛出异常：
1 class Example4 extends Thread {
2 public static void main(String args[]) throws Exception {
3 final Object lock1 = new Object();
4 final Object lock2 = new Object();
5 Thread thread1 = new Thread() {
6 public void run() {
7 deathLock(lock1, lock2);
8 }
9 };
10 Thread thread2 = new Thread() {
11 public void run() {
12 // 注意，这里在交换了一下位置
13 deathLock(lock2, lock1);
14 }
15 };
16 System.out.println("Starting thread...");
17 thread1.start();
18 thread2.start();
19 Thread.sleep(3000);
20 System.out.println("Interrupting thread...");
21 thread1.interrupt();
22 thread2.interrupt();
23 Thread.sleep(3000);
24 System.out.println("Stopping application...");
25 }
26
27 static void deathLock(Object lock1, Object lock2) {
28 try {
29 synchronized (lock1) {
30 Thread.sleep(10);// 不会在这里死掉
31 synchronized (lock2) {// 会锁在这里，虽然阻塞了，但不会抛异常
32 System.out.println(Thread.currentThread());
33 }
34 }
35 } catch (InterruptedException e) {
36 e.printStackTrace();
37 System.exit(1);
38 }
39 }
40 }
中断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()将不起作用，因为线程将不会退出被阻塞状态。Example5描述了这一行为。尽管interrupt()被调用，线程也不会退出被阻塞状态，比如ServerSocket的accept方法根本不抛出异常。
很幸运，Java平台为这种情形提供了一项解决方案，即调用阻塞该线程的套接字的close()方法。在这种情形下，如果线程被I/O操作阻塞，当调用该套接字的close方法时，该线程在调用accept地方法将接收到一个SocketException（SocketException为IOException的子异常）异常，这与使用interrupt()方法引起一个InterruptedException异常被抛出非常相似，（注，如果是流因读写阻塞后，调用流的close方法也会被阻塞，根本不能调用，更不会抛IOExcepiton，此种情况下怎样中断？我想可以转换为通道来操作流可以解决，比如文件通道）。下面是具体实现：
1 class Example6 extends Thread {
2 volatile ServerSocket socket;
3
4 public static void main(String args[]) throws Exception {
5 Example6 thread = new Example6();
6 System.out.println("Starting thread...");
7 thread.start();
8 Thread.sleep(3000);
9 System.out.println("Asking thread to stop...");
10 Thread.currentThread().interrupt();// 再调用interrupt方法
11 thread.socket.close();// 再调用close方法
12 try {
13 Thread.sleep(3000);
14 } catch (InterruptedException e) {
15 }
16 System.out.println("Stopping application...");
17 }
18
19 public void run() {
20 try {
21 socket = new ServerSocket(8888);
22 } catch (IOException e) {
23 System.out.println("Could not create the socket...");
24 return;
25 }
26 while (!Thread.currentThread().isInterrupted()) {
27 System.out.println("Waiting for connection...");
28 try {
29 socket.accept();
30 } catch (IOException e) {
31 System.out.println("accept() failed or interrupted...");
32 Thread.currentThread().interrupt();//重新设置中断标示位
33 }
34 }
35 System.out.println("Thread exiting under request...");
36 }
37 }
一、没有任何语言方面的需求一个被中断的线程应该终止。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断。
二、对于处于sleep，join等操作的线程，如果被调用interrupt()后，会抛出InterruptedException，然后线程的中断标志位会由true重置为false，因为线程为了处理异常已经重新处于就绪状态。
三、不可中断的操作，包括进入synchronized段以及Lock.lock()，inputSteam.read()等，调用interrupt()对于这几个问题无效，因为它们都不抛出中断异常。如果拿不到资源，它们会无限期阻塞下去。
对于Lock.lock()，可以改用Lock.lockInterruptibly()，可被中断的加锁操作，它可以抛出中断异常。等同于等待时间无限长的Lock.tryLock(long time, TimeUnit unit)。
对于inputStream等资源，有些(实现了interruptibleChannel接口)可以通过close()方法将资源关闭，对应的阻塞也会被放开。
首先，看看Thread类里的几个方法：
| public static boolean interrupted | 测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false。 |
public boolean isInterrupted() |
测试线程是否已经中断。线程的中断状态 不受该方法的影响。 |
public void interrupt() |
中断线程。 |
上面列出了与中断有关的几个方法及其行为，可以看到interrupt是中断线程。如果不了解Java的中断机制，这样的一种解释极容易造成误解，认为调用了线程的interrupt方法就一定会中断线程。
其实，Java的中断是一种协作机制。也就是说调用线程对象的interrupt方法并不一定就中断了正在运行的线程，它只是要求线程自己在合适的时机中断自己。每个线程都有一个boolean的中断状态（这个状态不在Thread的属性上），interrupt方法仅仅只是将该状态置为true(比如说上面的Example2中，抛出异常，然后在catch中可以决定要不要中断)。
比如对正常运行的线程调用interrupt()并不能终止他，只是改变了interrupt标示符。
一般说来，如果一个方法声明抛出InterruptedException，表示该方法是可中断的,比如wait,sleep,join，也就是说可中断方法会对interrupt调用做出响应（例如sleep响应interrupt的操作包括清除中断状态，抛出InterruptedException）,异常都是由可中断方法自己抛出来的，并不是直接由interrupt方法直接引起的。
Object.wait, Thread.sleep方法，会不断的轮询监听 interrupted 标志位，发现其设置为true后，会停止阻塞并抛出 InterruptedException异常。
以上除了Example3都是http://www.cnblogs.com/onlywujun/p/3565082.html的整理。