有关线程中断和线程阻塞

一个线程都要从运行到结束都要经过3个阶段：

1、正在运行

2、准备结束运行

3、结束运行

那么怎么结束这个线程呢？可以通过下面这三个方法结束一个线程。

1、使用stop()方法强制结束线程。

2、使用thread.interrupt()方法发送中断。

3、在Thread对象中设置共享变量，通过在run方法中不断检测该变量的值来决定是否结束。

第一种方法，stop()方法。

臭名昭著的stop()停止线程的方法已不提倡使用了,原因是什么呢?当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，并抛出特殊的ThreadDeath()异常。这里的“立即”因为太“立即”了，假如一个线程正在执行：

synchronized void {
 x = 3;
 y = 4;
}

由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了 stop()方法，即使在同步块中，它也干脆地stop了，这样就产生了不完整

的残废数据。而多线程编程中最最基础的条件要保证数据的完整性，所以请忘记 线程的stop方法，以后我们再也不要说“停止线程”了。

第二种方法，中断线程。

每个线程都有一个线程中断标志位来标志该线程是否被中断。我们可以通过检测该标志位是否为true来判断该线程是否被中断。调用线程的thread.interrupt()方法，将会设置该线程为中断状态，即设置为true。线程中断后的结果是死亡、还是等待新的任务或是继续运行至下一步，取决于这个程序本身。线程会不时地检测这个中断标识位，以判断线程是否应该被中断（中断标识值是否为true）。它并不像stop方法那样会中断一个正在运行的线程。

当我们调用thread.interrupt()方法时，会将thread的中断标志位设为true。通过isInterrupted()方法可以判断标志位是否为true。此后程序是该继续还是结束就取决于程序本身了。

注意：如果一个线程处于了阻塞状态（如线程调用了thread.sleep、thread.join、thread.wait、1.5中的condition.await、以及可中断的通道上的 I/O 操作方法后可进入阻塞状态），则在线程在检查中断标识时如果发现中断标示为true，则会在这些阻塞方法（sleep、join、wait、1.5中的condition.await及可中断的通道上的 I/O 操作方法）调用处抛出InterruptedException异常，并且在抛出异常后立即将线程的中断标别位清除，即重新设置为false。抛出异常是为了线程从阻塞状态醒过来，并在结束线程前让程序员有足够的时间来处理中断请求。一个抛出了InterruptedException的线程的状态马上就会被置为非中断状态，如果catch语句没有处理异常，则下一 次循环中isInterrupted()为false，线程会继续执行，可能你N次抛出异常，也无法让线程停止。例如下面例子：

public class ThreadA extends Thread {
   int count=0;
   public void run(){
       System.out.println(getName()+"将要运行...");
       while(!this.isInterrupted()){
           System.out.println(getName()+"运行中"+count++);
           try{
               Thread.sleep(400);
           }catch(InterruptedException e){
               System.out.println(getName()+"从阻塞中退出...");
               System.out.println("this.isInterrupted()="+this.isInterrupted());
           }
       }
       System.out.println(getName()+"已经终止!");
   }
}

因为上例中try在while循环里面，当检测到异常时会执行打印语句，当再次进行while(!this.isInterrupted())判定的时候，请注意，由于此时中断标志位已经被重置为false了，所以while循环会一直继续下去。

public class ThreadA extends Thread {
   int count=0;
   public void run(){
       System.out.println(getName()+"将要运行...");
       while(!this.isInterrupted()){
           System.out.println(getName()+"运行中"+count++);
           try{
               Thread.sleep(400);
           }catch(InterruptedException e){
	       this.interrupt();
               System.out.println(getName()+"从阻塞中退出...");
               System.out.println("this.isInterrupted()="+this.isInterrupted());
           }
       }
       System.out.println(getName()+"已经终止!");
   }
}

比较良好处理方法是：

public void 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 {   
        //线程结束前做一些清理工作   
    }   
}

注，synchronized在获锁的过程中是不能被中断的，意思是说如果产生了死锁，则不可能被中断（请参考后面的测试例子）。与synchronized功能相似的reentrantLock.lock()方法也是一样，它也不可中断的，即如果发生死锁，那么reentrantLock.lock()方法无法终止，如果调用时被阻塞，则它一直阻塞到它获取到锁为止。但是如果调用带超时的tryLock方法reentrantLock.tryLock(long timeout, TimeUnit unit)，那么如果线程在等待时被中断，将抛出一个InterruptedException异常，这是一个非常有用的特性，因为它允许程序打破死锁。你也可以调用reentrantLock.lockInterruptibly()方法，它就相当于一个超时设为无限的tryLock方法。

另外不要在你的底层代码里捕获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().interrupted();   
    }   
    ...   
}

2、或者，更好的做法就是，不使用try来捕获这样的异常，让方法直接抛出

void mySubTask() throws InterruptedException {   
    ...   
    sleep(delay);   
    ...   
} 

第三个方法，设置中断信号量。

中断线程最好的，最受推荐的方式是，使用共享变量（shared variable）发出信号，告诉线程必须停止正在运行的任务。线程必须周期性的核查这一变量，然后有秩序地中止任务。

package com.ljq.test;

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!");   
    }
}

注意：这里将stop变量定义为volatile类型，防止由于本地缓存产生错误。

参考文章：

http://www.cnblogs.com/linjiqin/archive/2011/04/11/2012695.html

http://blog.csdn.net/oscar999/article/details/1755759