Java 终止线程

Java Thread.interrupt( )中断线程

使用Thread.interrupt（）中断线程

正如Listing A中所描述的，Thread.interrupt（）方法不会中断一个正在运行的线程。这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait， Thread.join和 Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。

因此，如果线程被上述几种方法阻塞，正确的停止线程方式是设置共享变量，并调用interrupt（）（注意变量应该先设置）。如果线程没有被阻塞，这时调用interrupt（）将不起作用；否则，线程就将得到异常（该线程必须事先预备好处理此状况），接着逃离阻塞状态。在任何一种情况中，最后线程都将检查共享变量然后再停止。Listing C这个示例描述了该技术。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

Listing C   class  Example3 extends  Thread {        volatile  boolean  stop = false ;        public  static  void  main(String args[]) throws  Exception {          Example3 thread = new  Example3();          System.out.println( "Starting thread..." );          thread.start();          Thread.sleep( 3000 );          System.out.println( "Asking thread to stop..." );          thread.stop = true ; //如果线程阻塞，将不会检查此变量          thread.interrupt();          Thread.sleep( 3000 );          System.out.println( "Stopping application..." );          //System.exit( 0 );      }        public  void  run() {          while  (!stop) {              System.out.println( "Thread running..." );              try  {                  Thread.sleep( 1000 );              } catch  (InterruptedException e) {                  System.out.println( "Thread interrupted..." );              }          }          System.out.println( "Thread exiting under request..." );      } }

    一旦Listing C中的Thread.interrupt（）被调用，线程便收到一个异常，于是逃离了阻塞状态并确定应该停止。运行以上代码将得到下面的输出：

?

1 2 3 4 5 6 7 8

Starting thread... Thread running... Thread running... Thread running... Asking thread to stop... Thread interrupted... Thread exiting under request... Stopping application...

中断I/O操作

然而，如果线程在I/O操作进行时被阻塞，又会如何？I/O操作可以阻塞线程一段相当长的时间，特别是牵扯到网络应用时。例如，服务器可能需要等待一个请求（request），又或者，一个网络应用程序可能要等待远端主机的响应。

如果你正使用通道（channels）（这是在Java 1.4中引入的新的I/O API），那么被阻塞的线程将收到一个 ClosedByInterruptException异常。如果情况是这样，其代码的逻辑和第三个例子中的是一样的，只是异常不同而已。

但是，你可能正使用Java1.0之前就存在的传统的I/O，而且要求更多的工作。既然这样，Thread.interrupt（）将不起作用，因为线程将不会退出被阻塞状态。Listing D描述了这一行为。尽管interrupt（）被调用，线程也不会退出被阻塞状态。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

Listing D import  java.io.*;   class  Example4 extends  Thread {      public  static  void  main( String args[] ) throws  Exception {          Example4 thread = new  Example4();          System.out.println( "Starting thread..." );          thread.start();          Thread.sleep( 3000 );          System.out.println( "Interrupting thread..." );          thread.interrupt();          Thread.sleep( 3000 );          System.out.println( "Stopping application..." );          //System.exit( 0 );      }        public  void  run() {          ServerSocket socket;          try  {              socket = new  ServerSocket( 7856 );          } catch  (IOException e) {              System.out.println( "Could not create the socket..." );              return ;          }          while  ( true ) {              System.out.println( "Waiting for connection..." );              try  {                  Socket sock = socket.accept();              } catch  (IOException e) {                  System.out.println( "accept() failed or interrupted..." );              }          }      } }

很幸运，Java平台为这种情形提供了一项解决方案，即调用阻塞该线程的套接字的close（）方法。在这种情形下，如果线程被I/O操作阻塞，该线程将接收到一个SocketException异常，这与使用interrupt（）方法引起一个InterruptedException异常被抛出非常相似。

唯一要说明的是，必须存在socket的引用（reference），只有这样close（）方法才能被调用。这意味着socket对象必须被共享。Listing E描述了这一情形。运行逻辑和以前的示例是相同的。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

Listing E import  java.net.*; import  java.io.*;   class  Example5 extends  Thread {      volatile  boolean  stop = false ;      volatile  ServerSocket socket;        public  static  void  main(String args[]) throws  Exception {          Example5 thread = new  Example5();          System.out.println( "Starting thread..." );          thread.start();          Thread.sleep( 3000 );          System.out.println( "Asking thread to stop..." );          thread.stop = true ;          thread.socket.close();          Thread.sleep( 3000 );          System.out.println( "Stopping application..." );          //System.exit( 0 );      }        public  void  run() {          try  {              socket = new  ServerSocket( 7856 );          } catch  (IOException e) {              System.out.println( "Could not create the socket..." );              return ;          }          while  (!stop) {              System.out.println( "Waiting for connection..." );              try  {                  Socket sock = socket.accept();              } catch  (IOException e) {                  System.out.println( "accept() failed or interrupted..." );              }          }          System.out.println( "Thread exiting under request..." );      } }

    以下是运行Listing E中代码后的输出：

?

1 2 3 4 5 6

Starting thread... Waiting for  connection... Asking thread to stop... accept() failed or interrupted... Thread exiting under request... Stopping application...

多线程是一个强大的工具，然而它正呈现出一系列难题。其中之一是如何中断一个正在运行的线程。如果恰当地实现，使用上述技术中断线程将比使用Java平台上已经提供的内嵌操作更为简单。

---

[线程的interrupt()方法,interrupted()和isInterrupted()] 的区别

　　这三个方法是关系非常密切而且又比较复杂的,虽然它们各自的功能很清楚,但它们之间的关系有大多数 人不是真正的了解. 

　　interrupt()方法,它是实例方法,而它也是最奇怪的方法,在java语言中,线程最初被设计为 "隐晦难懂 " 的东西,直到现在它的语义不没有象它的名字那样准确. 
     

　　大多数人以为,一个线程象调用了interrupt()方法,那它对应的线程就应该被中断而抛出异常, 事实中,当一个线程对象调用interrupt()方法,它对应的线程并没有被中断,只是改变了它的中断状态. 使当前线程的状态变以中断状态,如果没有其它影响,线程还会自己继续执行. 只有当线程执行到sleep,wait,join等方法时,或者自己检查中断状态而抛出异常的情况下,线程 才会抛出异常. 

　　如果线程对象调用interrupt()后它对应的线程就立即中断,那么interrupted()方法就不可能执行. 因为interrupted()方法是一个static方法,就是说只能在当前线程上调用,而如果一个线程interrupt()后它已经中断了,那它又如何让自己interrupted()? 
        

　　正因为一个线程调用interrupt()后只是改变了中断状态,它可以继续执行下去,在没有调用sleep, wait,join等法或自己抛出异常之前,它就可以调用interrupted()来清除中断状态(还会原状) 
interrupted()方法会检查当前线程的中断状态,如果为 "被中断状态 "则改变当前线程为 "非中断状态 "并返回true,如果为 "非中断状态 "则返回false,它不仅检查当前线程是否为中断状态,而且在保证当前线程回来非中断状态,所以它叫 "interrupted ",是说中断的状态已经结束(到非中断状态了) 

　　isInterrupted()方法则仅仅检查线程对象对应的线程是否是中断状态,并不改变它的状态. 
        
　　目前大家只能先记住这三个方法的功能,只有真正深入到多线程编程实践中,才会体会到它们为什么 是对象方法,为什么是类方法.

原文链接：http://www.cnblogs.com/biGpython/archive/2012/03/05/2380858.html