java 间断运行线程

java 中断运行线程

?

1. class?Example1?extends?Thread?{??
2. 　　　　　　boolean?stop=false;??
3. 　　　　　　public?static?void?main(?String?args[]?)?throws?Exception?{??
4. 　　　　　　Example1?thread?=?new?Example1();??
5. 　　　　　　System.out.println(?"Starting?thread..."?);??
6. 　　　　　　thread.start();??
7. 　　　　　　Thread.sleep(?3000?);??
8. 　　　　　　System.out.println(?"Interrupting?thread..."?);??
9. 　　　　　　thread.interrupt();??
10. 　　　　　　Thread.sleep(?3000?);??
11. 　　　　　　System.out.println("Stopping?application..."?);??
12. 　　　　　　//System.exit(0);??
13. 　　　　　　}??
14. 　　　　　　public?void?run()?{??
15. 　　　　　　while(!stop){??
16. 　　　　　　System.out.println(?"Thread?is?running..."?);??
17. 　　　　　　long?time?=?System.currentTimeMillis();??
18. 　　　　　　while((System.currentTimeMillis()-time?<?1000))?{??
19. 　　　　　　}??
20. 　　　　　　}??
21. 　　　　　　System.out.println("Thread?exiting?under?request..."?);??
22. 　　　　　　}??
23. 　　　　　　}??

?

　　如果你运行了Listing A中的代码，你将在控制台看到以下输出：

1. Starting?thread...??
2. Thread?is?running...??
3. Thread?is?running...??
4. Thread?is?running...??
5. Interrupting?thread...??
6. Thread?is?running...??
7. Thread?is?running...??
8. Thread?is?running...??
9. Stopping?application...??
10. Thread?is?running...??
11. Thread?is?running...??
12. Thread?is?running...??
13. ...............................??

?

　甚至，在Thread.interrupt（）被调用后，线程仍然继续运行。

　　真正地中断一个线程

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

1. /*Listing?B*/??
2. class?Example2?extends?Thread?{??
3. 　volatile?boolean?stop?=?false;??
4. 　public?static?void?main(?String?args[]?)?throws?Exception?{??
5. 　　Example2?thread?=?new?Example2();??
6. 　?System.out.println(?"Starting?thread..."?);??
7. 　?thread.start();??
8. 　?Thread.sleep(?3000?);??
9. 　?System.out.println(?"Asking?thread?to?stop..."?);??
10. 　?thread.stop?=?true;??
11. 　?Thread.sleep(?3000?);??
12. 　?System.out.println(?"Stopping?application..."?);??
13. 　?//System.exit(?0?);??
14. 　}??
15. 　public?void?run()?{??
16. 　　while?(?!stop?)?{??
17. 　　?System.out.println(?"Thread?is?running..."?);??
18. 　　　long?time?=?System.currentTimeMillis();??
19. 　　　while?(?(System.currentTimeMillis()-time?<?1000)?&&?(!stop)?)?{??
20. 　　　}??
21. 　　}??
22. 　?System.out.println(?"Thread?exiting?under?request..."?);??
23. 　}??
24. }??

?　　运行Listing B中的代码将产生如下输出（注意线程是如何有秩序的退出的）

?

1. Starting?thread...??
2. Thread?is?running...??
3. Thread?is?running...??
4. Thread?is?running...??
5. Asking?thread?to?stop...??
6. Thread?exiting?under?request...??
7. Stopping?application...??

?

　虽然该方法要求一些编码，但并不难实现。同时，它给予线程机会进行必要的清理工作，这在任何一个多线程应用程序中都是绝对需要的。请确认将共享变 量定义成volatile 类型或将对它的一切访问封入同步的块/方法（synchronized blocks/methods）中。

　 　到目前为止一切顺利！但是，当线程等待某些事件发生而被阻塞，又会发生什么？当然，如果线程被阻塞，它便不能核查共享变量，也就不能停止。这在许多情况 下会发生，例如调用Object.wait（）、ServerSocket.accept（）和DatagramSocket.receive（）时，这 里仅举出一些。

　　他们都可能永久的阻塞线程。即使发生超时，在超时期满之前持续等待也是不可行和不适当的，所以，要使用某种机制使得线程更早地退出被阻塞的状态。

　　很不幸运，不存在这样一种机制对所有的情况都适用，但是，根据情况不同却可以使用特定的技术。在下面的环节，我将解答一下最普遍的例子。

　　使用Thread.interrupt（）中断线程

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

?

?

?

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

?

1. /*Listing?C*/??
2. class?Example3?extends?Thread?{??
3. 　volatile?boolean?stop?=?false;??
4. 　public?static?void?main(?String?args[]?)?throws?Exception?{??
5. 　?Example3?thread?=?new?Example3();??
6. 　?System.out.println(?"Starting?thread..."?);??
7. 　?thread.start();??
8. 　?Thread.sleep(?3000?);??
9. 　?System.out.println(?"Asking?thread?to?stop..."?);??
10. 　?thread.stop?=?true;//如果线程阻塞，将不会检查此变量??
11. 　?thread.interrupt();??
12. 　?Thread.sleep(?3000?);??
13. 　?System.out.println(?"Stopping?application..."?);??
14. 　?//System.exit(?0?);??
15. 　}??
16. 　public?void?run()?{??
17. 　　while?(?!stop?)?{??
18. 　　?System.out.println(?"Thread?running..."?);??
19. 　　　try?{??
20. 　　　Thread.sleep(?1000?);??
21. 　　　}?catch?(?InterruptedException?e?)?{??
22. 　　　System.out.println(?"Thread?interrupted..."?);??
23. 　　　}??
24. 　　}??
25. 　?System.out.println(?"Thread?exiting?under?request..."?);??
26. 　}??
27. }??

?

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

?

1. Starting?thread...??
2. Thread?running...??
3. Thread?running...??
4. Thread?running...??
5. Asking?thread?to?stop...??
6. Thread?interrupted...??
7. Thread?exiting?under?request...??
8. 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. Listing?D??
2. import?java.io.*;??
3. class?Example4?extends?Thread?{??
4. 　public?static?void?main(?String?args[]?)?throws?Exception?{??
5. 　　Example4?thread?=?new?Example4();??
6. 　?System.out.println(?"Starting?thread..."?);??
7. 　?thread.start();??
8. 　?Thread.sleep(?3000?);??
9. 　?System.out.println(?"Interrupting?thread..."?);??
10. 　?thread.interrupt();??
11. 　?Thread.sleep(?3000?);??
12. 　?System.out.println(?"Stopping?application..."?);??
13. 　?//System.exit(?0?);??
14. 　}??
15. 　public?void?run()?{??
16. 　?ServerSocket?socket;??
17. 　　try?{??
18. 　　　socket?=?new?ServerSocket(7856);??
19. 　　}?catch?(?IOException?e?)?{??
20. 　　?System.out.println(?"Could?not?create?the?socket..."?);??
21. 　　　return;??
22. 　　}??
23. 　　while?(?true?)?{??
24. 　　?System.out.println(?"Waiting?for?connection..."?);??
25. 　　　try?{??
26. 　　　?Socket?sock?=?socket.accept();??
27. 　　　}?catch?(?IOException?e?)?{??
28. 　　　System.out.println(?"accept()?failed?or?interrupted..."?);??
29. 　　　}??
30. 　　}??
31. 　}??
32. }??

?

?

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

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

1. /*Listing?E*/??
2. import?java.net.*;??
3. import?java.io.*;??
4. class?Example5?extends?Thread?{??
5. 　volatile?boolean?stop?=?false;??
6. 　volatile?ServerSocket?socket;??
7. 　public?static?void?main(?String?args[]?)?throws?Exception?{??
8. 　　Example5?thread?=?new?Example5();??
9. 　?System.out.println(?"Starting?thread..."?);??
10. 　?thread.start();??
11. 　?Thread.sleep(?3000?);??
12. 　?System.out.println(?"Asking?thread?to?stop..."?);??
13. 　?thread.stop?=?true;??
14. 　?thread.socket.close();??
15. 　?Thread.sleep(?3000?);??
16. 　?System.out.println(?"Stopping?application..."?);??
17. 　?//System.exit(?0?);??
18. 　}??
19. 　public?void?run()?{??
20. 　　try?{??
21. 　　　socket?=?new?ServerSocket(7856);??
22. 　　}?catch?(?IOException?e?)?{??
23. 　　?System.out.println(?"Could?not?create?the?socket..."?);??
24. 　　　return;??
25. 　　}??
26. 　　while?(?!stop?)?{??
27. 　　?System.out.println(?"Waiting?for?connection..."?);??
28. 　　　try?{??
29. 　　　?Socket?sock?=?socket.accept();??
30. 　　　}?catch?(?IOException?e?)?{??
31. 　　　System.out.println(?"accept()?failed?or?interrupted..."?);??
32. 　　　}??
33. 　　}??
34. 　?System.out.println(?"Thread?exiting?under?request..."?);??
35. 　}??
36. }??

?

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

1. Starting?thread...??
2. Waiting?for?connection...??
3. Asking?thread?to?stop...??
4. accept()?failed?or?interrupted...??
5. Thread?exiting?under?request...??
6. Stopping?application...??

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

?