Java Thread.interrupt( )中断线程

使用Thread.interrupt（）中断线程

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

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

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（）被调用，线程便收到一个异常，于是逃离了阻塞状态并确定应该停止。运行以上代码将得到下面的输出：

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（）被调用，线程也不会退出被阻塞状态。

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描述了这一情形。运行逻辑和以前的示例是相同的。

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中代码后的输出：

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