【IT168 技术文章】在多线程代码中，使用驱动其它线程所负责的动作的单个主线程是常见的。这个主线程发送消息，通常是通过把它们放到一个队列中，然后其它线程处理这些消息。但是如果主线程抛出一个异常，那么剩余的线程会继续运行，等待更多输入到该队列，导致程序冻结。
用多线程编写代码对程序员大有好处。多线程能使编程(和程序)进行得快得多，而且代码能有效得多地使用资源。然而，跟生活中的很多事情一样，多线程也存在缺点。因为多线程代码天生是非确定性的，出现错误的可能性大得多。而且，确实发生的的错误很难重现，因此也更难解决。
孤线程模式
Java 编程语言为多线程代码提供了丰富的支持，包括一项特别有用的功能：能够在一个线程中抛出一个异常而不影响其它线程。但这项功能会导致很多难以跟踪的错误。
从某个线程的崩溃中恢复过来是有意义，在此种情况下，这种能力能增加程序的健壮性级别。然而，它也使我们难以判断这些线程之一在什么时候抛出了一个异常。因为剩余的线程将继续运行，所以程序会表现出无响应或冻结程序的征兆。对线程之间频繁通信的程序而言尤其如此。
考虑清单 1 所示的示例，其中的一对线程通过生产者-消费者模型进行通信。
清单 1. 一个简单的、多线程的消费者-生产者程序
2 Client client;
3 int counter;
4 public Server(Client _client) {
5 this.client = _client;
6 this.counter = 0;
7 }
8 public void run() {
9 while (counter < 10) {
10 this.client.queue.addElement(new Integer(counter));
11 counter++;
12 }
13 throw new RuntimeException("counter >= 10");
14 }
15 public static void main(String[] args) {
16 Client c = new Client();
17 Server s = new Server(c);
18 c.start();
19 s.start();
20 }
21 }
22 class Client extends Thread {
23 Vector queue;
24 public Client() {
25 this.queue = new Vector();
26 }
27 public void run() {
28 while (true) {
29 if (! (queue.size() == 0)) {
30 processNextElement();
31 }
32 }
33 }
34 private void processNextElement() {
35 Object next = queue.elementAt(0);
36 queue.removeElementAt(0);
37 System.out.println(next);
38 }
39 }
40
在诸如这样的案例中，第二个线程接收用于计算的任何数据完全依赖于第一个线程。因此，不可避免地，如果第一个线程崩溃(而在这个样本中，肯定是这样的)，那么第二个线程将等待永远不会到来的更多输入。现在您知道我为什么把这种错误叫做 孤线程模式。
症状
这种错误模式最常见的症状是我在前面提到的 ― 即，程序好象冻结了。
其它症状可能包括打印到程序标准错误和标准输出的堆栈跟踪实际停止了。
治疗和预防措施
一旦诊断出这种错误模式，查找并修复在崩溃线程中的潜在的错误是显然的治疗之道。但是预防却困难得多。
不用说，如果您使用单线程设计就能侥幸成功，那么将可以免除很多头痛的事情。然而，当程序的性能要求是必须考虑的问题时，就要首先考虑使用多线程设计。
诊断这种崩溃的一个辅助手段是捕捉由各种线程抛出的异常并在退出之前通知该问题的依赖线程。这正是我在清单 2 中所做的。
清单 2. 把错误通知给客户机线程的示例
2 public class Server2 extends Thread {
3 Client2 client;
4 int counter;
5 public Server2(Client2 _client) {
6 this.client = _client;
7 this.counter = 0;
8 }
9 public void run() {
10 try {
11 while (counter < 10) {
12 this.client.queue.addElement(new Integer(counter));
13 counter++;
14 }
15 throw new RuntimeException("counter >= 10");
16 }
17 catch (Exception e) {
18 this.client.interruptFlag = true;
19 throw new RuntimeException(e.toString());
20 }
21 }
22 public static void main(String[] args) {
23 Client2 c = new Client2();
24 Server2 s = new Server2(c);
25 c.start();
26 s.start();
27 }
28 }
29 class Client2 extends Thread {
30 Vector queue;
31 boolean interruptFlag;
32 public Client2() {
33 this.queue = new Vector();
34 this.interruptFlag = false;
35 }
36 public void run() {
37 while (! interruptFlag) {
38 if (! (queue.size() == 0)) {
39 processNextElement();
40 }
41 }
42 // Processes whatever elements remain on the queue before exiting.
43 while (! (queue.size() == 0)) {
44 processNextElement();
45 }
46 System.out.flush();
47 }
48 private void processNextElement() {
49 Object next = queue.elementAt(0);
50 queue.removeElementAt(0);
51 System.out.println(next);
52 }
53 }
54
处理被抛出的异常的其它选项可能是调用 System.exit 。这个选项在程序的主线程发生崩溃而其它线程不管理任何临界资源的时候是有意义的。然而在其它情况下，这可能是危险的。例如，考虑这样一个示例，其它线程中的一个正在管理一个打开的文件。如果这是实际的情况，那么只是退出程序会导致资源泄漏。
即使在上面的简单示例中，在 server 线程中调用 System.exit 也会导致 client 未处理其队列上的任何剩余元素就退出。
事实上，就是这样的问题促使 Sun 不建议线程的 stop 方法。由于强行停止一个线程会使资源陷入非一致状态，所以 stop 方法破坏了语言的安全性模型。
总结
这里是本周错误模式的总结：
模式：孤线程
症状：一个锁定多线程程序，它具有或不具有将堆栈跟踪打印到标准错误。
致因：多个程序线程一直等待来自某个线程的输入，而该线程在抛出一个未被捕捉的异常后就退出了。
治疗和预防措施：把异常处理代码放到主线程中以在崩溃来临之际通知依赖线程。
