【解惑】 中断线程Interrupted的用处

★ 线程状态

       Java虚拟机将线程运行过程分成四种状态 。 (1) New 新生；(2) Runnable 可运行；(3) Blocked 阻塞；(4) Dead 死亡。

      值得注意的是： 线程的可运行状态并不代表线程一定在运行(runnable != running ) 。 大家都知道：所有现代桌面和服务器操作系统都使用了抢占式的线程调度策略 。一旦线程开始执行，并不是总是保持持续运行状态的。当系统分给它的时间片(非常小的运行时间单位)用完以后，不管程序有没有执行完，线程被强制放弃CPU，进入就绪状态，直到下次被调度后开始继续执行。也就是说， Runnable可运行状态的线程处于两种可能的情况下：(1)占用CPU运行中，(2)等待调度的就绪状态。 这里要声明一下：处于等待调度的就绪状态线程和处于阻塞的线程是完全不同的。就绪的线程是因为时间片用完而放弃CPU，其随时都有可能再次获得CPU而运行，这一切取决于分时OS的线程调度策略。

       在很多操作系统的专业术语中，这种因时间片用完而被剥夺CPU的情况我们叫做线程中断 。注意这和我们下面要将得中断线程是两个完全不同的概念。事实上，我们不可能通过应用程序来控制CPU的线程中断，除非我们能够自由调用OS的内核。

★ 中断线程 —— interrupt()

       一个正在运行的线程除了正常的时间片中断之外，能否被其他线程控制？或者说其他线程能否让指定线程放弃CPU或者提前结束运行？ 除了线程同步机制之外，还有两种方法：
       (1) Thread.stop(), Thread.suspend(), Thread.resume() 和Runtime.runFinalizersOnExit() 这些终止线程运行的方法 。这些方法已经被废弃，使用它们是极端不安全的。
       (2) Thread.interrupt() 方法是很好的选择。但是使用的时候我们必须好好理解一下它的用处。

 //无法中断正在运行的线程代码  
 class TestRunnable implements Runnable{  
       public void run(){  
             while(true)  
             {  
                   System.out.println( "Thread is running..." );  
                   long time = System.currentTimeMillis();//去系统时间的毫秒数  
             while((System.currentTimeMillis()-time < 1000)) {  
                    //程序循环1秒钟，不同于sleep(1000)会阻塞进程。  
             }  
               }  
        }  
 }  
 public class ThreadDemo{  
          public static void main(String[] args){  
                Runnable r=new TestRunnable();  
                Thread th1=new Thread(r);  
                th1.start();  
                th1.interrupt();           
         }  
 }  
//运行结果：一秒钟打印一次Thread is running...。程序没有终止的任何迹象 

      上面的代码说明interrupt()并没有中断一个正在运行的线程，或者说让一个running中的线程放弃CPU。那么interrupt到底中断什么。

       首先我们看看interrupt究竟在干什么。

       当我们调用th1.interrput()的时候，线程th1的中断状态(interrupted status) 会被置位。我们可以通过Thread.currentThread().isInterrupted() 来检查这个布尔型的中断状态。

        在Core Java中有这样一句话："没有任何语言方面的需求要求一个被中断的程序应该终止。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断 "。好好体会这句话的含义，看看下面的代码：

 //Interrupted的经典使用代码  
 public void run(){  
         try{  
              ....  
              while(!Thread.currentThread().isInterrupted()&& more work to do){  
                     // do more work;  
              }  
         }catch(InterruptedException e){  
                     // thread was interrupted during sleep or wait  
         }  
         finally{  
                    // cleanup, if required  
         }  
 }  

       很显然，在上面代码中，while循环有一个决定因素就是需要不停的检查自己的中断状态。当外部线程调用该线程的interrupt 时，使得中断状态置位。这是该线程将终止循环，不在执行循环中的do more work了。

       这说明: interrupt中断的是线程的某一部分业务逻辑，前提是线程需要检查自己的中断状态(isInterrupted())。

       但是当th1被阻塞的时候，比如被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞时。调用它的interrput()方法。可想而知，没有占用CPU运行的线程是不可能给自己的中断状态置位的。这就会产生一个InterruptedException异常。

 //中断一个被阻塞的线程代码
class TestRunnable implements Runnable{
     public void run(){
          try{
	    Thread.sleep(1000000); //这个线程将被阻塞1000秒
       }catch(InterruptedException e){
	     e.printStackTrace();
                     //do more work and return.
          }
     }
}
public class TestDemo2{
      public static void main(String[] args) {
            Runnable tr=new TestRunnable();
            Thread th1=new Thread(tr);
            th1.start(); //开始执行分线程
        while(true){
	   th1.interrupt();  //中断这个分线程
        }
      }
}
/*运行结果:
   java.lang.InterruptedException: sleep interrupted
        at java.lang.Thread.sleep(Native Method)
        at TestRunnable.run(TestDemo2.java:4)
        at java.lang.Thread.run(Unknown Source)*/

 

 

评论

3 楼 honey_fansy 2017-03-15  

有点明白了

2 楼 clausewitzer 2011-11-04  

感谢，非常有帮助。

1 楼 shinestarwang 2010-05-03  

<div class="quote_title">使用finally要注意：</div>
<div class="quote_title">Heart.X.Raid 写道</div>
<div class="quote_div">
<p><span style="font-size: small;">       finally子句是不得不执行的。也正是由于它的这个特点，我们常常在程序异常跳出之前执行一些回收资源的动作。用Java编写的数据库程序就是很好的例子，我们总是要在程序中断前关闭所有与数据库的连接的。</span> </p>
<p><span style="font-size: small;">       finally子句的作用不容忽视，有了finally，是不是我们可以在程序结束前执行任何我们想执行的语句呢？也并非这样，有两类语句写在finally块中是需要好好斟酌的。</span> </p>
<p><span style="font-size: small;">      （1） return 语句</span> <span style="font-size: small;">public int f(int n){ try{ int r=n*n; return r; } finally{ if(n==2) return 0; //危险 } }
<pre></pre>
<p>        其中try中的return r;是没有任何作用的，因为在调用的方法返回之前必须执行方法中的finally子句。这样执行到return 0;其实该方法就结束了。比如我们调用f(2),结果返回的一定是0，这样原始值4就被忽略了。这种代码的清晰度是很差的。</p>
<p>        (2)   抛出异常语句</p>
InputStream in=....; try{ x(); //有可能抛出了非IOException } catch(IOException e){ e.printStackTrace(); } finally{ in.close(); //如果这里抛出了一个异常，就危险了 }
<pre></pre>
<p>         假设try块中的方法x()抛出了一个FileNotFoundException，而catch块捕捉的却是IOException异常。也就是说这个时候程序应该终止，并抛出FileNotFoundException，但是别忘了还有一个finally块必须先执行，好了，这个时候意外发生了，in.close()也出现异常了，并且抛出了一个IOException，没办法，开始的那个FileNotFoundException会丢失，结果只会抛出IOException而终止程序。</p>
<p> </p>
<p>        这两个问题怎么解决呢?其实也好办，就是尽量不要在finally块中写这两种语句，除非你明确不会出问题。</p>
<span style="font-size: small;">
<p> </p>
</span></span></p>
<p> </p>
</div>
<p> </p>