java线程中断[interrupt()函数] (转载)

一个正常的线程中断： 从运行到真正的结束，应该有三个阶段： 正常运行. 处理结束前的工作,也就是准备结束. 结束退出.
Java曾经提供过抢占式限制中断，但问题多多，例如的Thread.stop。另一方面，出于Java应用代码的健壮性的考虑，降低了编程门槛，减少不清楚底层机制的程序员无意破坏系统的概率，这个问题很多，比如：
　 当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，并抛出特殊的ThreadDeath()异常。这里的“立即”因为太“立即”了，
  一个线程正在执行：

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

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

　
由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了 stop()方法，即使在同步块中，它也干脆地stop了，这样就产生了不完整的残废数据。而多线程编程中最最基础的条件要保证数据的完整性，所以请忘记 线程的stop方法，以后我们再也不要说“停止线程”了。
　　 如何才能“结束”一个线程？
    如今，Java的线程调度不提供抢占式中断，而采用协作式的中断。其实，协作式的中断，原理很简单，就是轮询某个表示中断的标记，我们在任何普通代码的中都可以实现。 例如下面的代码：

1. volatile bool isInterrupted;
2. //…
3. while(!isInterrupted) {
4. compute();
5. }

    volatile bool isInterrupted;

    //…

    while(!isInterrupted) {

        compute();

    }

interrupt就是这样的一个通知，将Thead里的中断标志位设为true，而线程能否退出，就看用户的代码对于这个通知是怎么处理的了。
对于处于sleep，join等操作的线程，如果被调用interrupt()后，会抛出InterruptedException，然后线程的中断标志位会由true重置为false，因为线程为了处理异常已经重新处于就绪状态。
我在运行thinking in java里中断的例子时，一直都很奇怪为什么在catch(InterruptedException e)的处理段里，thead.isInterrupted()返回的都是false，原来是已被重置，所以很多导致无法中断线程，原因是出在这里。例如这段代码：

1. public class ThreadA extends Thread{
2. int count=0;
3. public void run(){
4. System.out.println(getName()+"将要运行...");
5. while(!this.isInterrupted()){
6. System.out.println(getName()+"运行中"+count++);
7. try{
8. Thread.sleep(400);
9. }catch(InterruptedException e){
10. System.out.println(getName()+"从阻塞中退出...");
11. System.out.println("this.isInterrupted()="+this.isInterrupted());
12. }
13. }
14. System.out.println(getName()+"已经终止!");
15. }
16. }

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()+"已经终止!");
   }
}

1. public class ThreadDemo{
2. public static void main(String argv[])throws InterruptedException{
3. ThreadA ta=new ThreadA();
4. ta.setName("ThreadA");
5. ta.start();
6. Thread.sleep(2000);
7. System.out.println(ta.getName()+"正在被中断...");
8. ta.interrupt();
9. System.out.println("ta.isInterrupted()="+ta.isInterrupted());
10. }
11. }

public class ThreadDemo{

    public static void main(String argv[])throws InterruptedException{
        ThreadA ta=new ThreadA();
        ta.setName("ThreadA");
        ta.start();
        Thread.sleep(2000);
        System.out.println(ta.getName()+"正在被中断...");
        ta.interrupt();
        System.out.println("ta.isInterrupted()="+ta.isInterrupted());
    }

}

这段代码ThreadA线程永远都无法中断。
    实际上，JVM内部确实为每个线程维护了一个中断标记。但应用程序不能直接访问这个中断变量，必须通过下面几个方法进行操作：

1. public class Thread {
2. //设置中断标记
3. public void interrupt() { ... }
4. //获取中断标记的值
5. public boolean isInterrupted() { ... }
6. //清除中断标记，并返回上一次中断标记的值
7. public static boolean interrupted() { ... }
8. ...
9. }

    public class Thread {
        //设置中断标记
        public void interrupt() { ... }
        //获取中断标记的值
        public boolean isInterrupted() { ... }
        //清除中断标记，并返回上一次中断标记的值
        public static boolean interrupted() { ... }
        ...
    }

如何使用中断标记来结束你的程序就是你自己来考虑的事了，事实上JVM只为我们设计一个中断标记而已。