java线程异常处理
2004 年 8 月 10 日
跟踪无法预期的运行时异常可能是一件又慢又费力的事情，只获得默认线程名称和堆栈跟踪通常是不够的。在 驯服 Tiger 这一期专栏中，Java 开发人员 John Zukowski 向您展示了如何通过替代默认行为来定制输出。他还对比了通过细分ThreadGroup定制输出的老方法与通过提供自己的UncaughtExceptionHandler定制输出的新方法。
虽然我们不想创建在无法预期时抛出运行时异常的程序，但这种情况还是会发生——尤其是第一次运行复杂程序时。通常是使用默认行为、打印堆栈溢出和结束线程的生命来处理这些异常。
从哪里发现默认行为？每个线程都属于一个由 java.lang.ThreadGroup 类表示的线程组。顾名思义，线程组允许您将线程组合在一起。您可能是为了方便而将线程组合，例如，一个线程池中的所有线程都属于组 X，而另一个池的所有线程则属于组 Y，或者是为了访问控制而将线程进行组合。组 X 中的线程无权访问或改变组 Y 中的线程，除非它们都在同一线程组内（或在一个子组内）。
在 Tiger 之前， ThreadGroup 类提供了一种处理未捕获异常的方法： ThreadGroup 的 uncaughtException() 方法。如果异常不是 ThreadDeath ，则将线程的名称和堆栈回溯（stack backtrace）发送到 System.err 。但是 Tiger 添加了另一种方法： Thread.UncaughtExceptionHandler 接口。细分 ThreadGroup 或安装该新接口的实现都允许您更改默认行为。我们将对 Tiger 之前和之后提供的方法都进行研究。
使用 ThreadGroup 的定制行为
发生未捕获的异常时，默认行为是将堆栈溢出打印输出到系统错误（ System.err ）中，如清单 1 中所示。不需要使用任何命令参数来启动程序。
清单 1. 线程溢出示例
public class SimpleDump {
public static void main(String args[]) {
System.out.println(args[0]);
}
}
|
不使用任何参数运行该程序将生成清单 2 中的输出。尽管它不是一个很长的堆栈跟踪，但它是一个完整的堆栈跟踪。
清单 2. 默认线程溢出输出
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
at SimpleDump.main(SimpleDump.java:3)
|
正如 Java 平台的许多东西一样，如果不喜欢默认行为，您可以对其进行更改。在 Java 平台的 Tiger 版以前的版本中，不能替代所有线程的默认行为，但是可以创建一个新的 ThreadGroup ，并更改在该组内创建的任何线程的默认行为。您可以重写 uncaughtException(Thread t, Throwable e) 方法来定制该行为。然后，当发生未预料的运行时异常时，该线程组内创建的任何线程都将获得新的行为。不过，最好是修复基础问题，我将提供一个简单的示例，说明更改默认行为所必需的步骤。清单 3 展示了将执行代码放入新线程的调整过的测试程序：
清单 3. 调整过的线程溢出示例
public class WindowDump {
public static void main(String args[]) throws Exception {
ThreadGroup group = new LoggingThreadGroup("Logger");
new Thread(group, "myThread") {
public void run() {
System.out.println(1 / 0);
}
}.start();
}
}
|
LoggingThreadGroup 类是一个新的内容，清单 4 中显示了它的定义。为了进行说明，通过重写 uncaughtException() 方法实现的特殊行为将在一个弹出窗口中显示该异常，这项操作是在特殊 Handler 的帮助下使用 Java Logging API 来完成的。
清单 4. LoggingThreadGroup 的定义
import java.util.logging.*;
public class LoggingThreadGroup extends ThreadGroup {
private static Logger logger;
public LoggingThreadGroup(String name) {
super(name);
}
public void uncaughtException(Thread t, Throwable e) {
// Initialize logger once
if (logger == null) {
logger = Logger.getLogger("example");
Handler handler = LoggingWindowHandler.getInstance();
logger.addHandler(handler);
}
logger.log(Level.WARNING, t.getName(), e);
}
}
|
这里创建的定制 Handler 的类型为 LoggingWindowHandler ，该类型的定义在清单 5 中。处理程序使用了一个支持类 LoggingWindow ，该类将异常显示在屏幕上。 清单 6 中显示了该类的定义。 Handler 的 public void publish(LogRecord record) 方法实现了一些重要操作。其余操作大部分只与配置有关。
清单 5. LoggingWindowHandler 的定义
import java.util.logging.*;
public class LoggingWindowHandler extends Handler {
private static LoggingWindow window;
private static LoggingWindowHandler handler;
private LoggingWindowHandler() {
configure();
window = new LoggingWindow("Logging window...", 400, 200);
}
public static synchronized LoggingWindowHandler getInstance() {
if (handler == null) {
handler = new LoggingWindowHandler();
}
return handler;
}
/**
* Get any configuration properties set
*/
private void configure() {
LogManager manager = LogManager.getLogManager();
String className = getClass().getName();
String level = manager.getProperty(className + ".level");
setLevel((level == null) ? Level.INFO : Level.parse(level));
String filter = manager.getProperty(className + ".filter");
setFilter(makeFilter(filter));
String formatter =
manager.getProperty(className + ".formatter");
setFormatter(makeFormatter(formatter));
}
private Filter makeFilter(String name) {
Filter f = null;
try {
Class c = Class.forName(name);
f = (Filter)c.newInstance();
} catch (Exception e) {
if (name != null) {
System.err.println("Unable to load filter: " + name);
}
}
return f;
}
private Formatter makeFormatter(String name) {
Formatter f = null;
try {
Class c = Class.forName(name);
f = (Formatter)c.newInstance();
} catch (Exception e) {
f = new SimpleFormatter();
}
return f;
}
// Overridden abstract Handler methods
public void close() {
}
public void flush() {
}
/**
* If record is loggable, format it and add it to window
*/
public void publish(LogRecord record) {
String message = null;
if (isLoggable(record)) {
try {
message = getFormatter().format(record);
} catch (Exception e) {
reportError(null, e, ErrorManager.FORMAT_FAILURE);
return;
}
try {
window.addLogInfo(message);
} catch (Exception e) {
reportError(null, e, ErrorManager.WRITE_FAILURE);
}
}
}
}
|
清单 6. LoggingWindow 的定义
import java.awt.*;
import javax.swing.*;
public class LoggingWindow extends JFrame {
private JTextArea textArea;
public LoggingWindow(String title, final int width,
final int height) {
super(title);
EventQueue.invokeLater(new Runnable() {
public void run() {
setSize(width, height);
textArea = new JTextArea();
JScrollPane pane = new JScrollPane(textArea);
textArea.setEditable(false);
getContentPane().add(pane);
setVisible(true);
}
});
}
public void addLogInfo(final String data) {
EventQueue.invokeLater(new Runnable() {
public void run() {
textArea.append(data);
}
});
}
}
|
执行 清单 3 中的 WindowDump 程序将出现图 1 中的屏幕。因为没有从 Logger 中删除控制台处理程序，所以堆栈溢出仍将出现在控制台上。
图 1. 记录的堆栈跟踪
发生运行时异常时，可能要做许多工作来更改发生的问题。该代码的大部分都是 Logging Handler，但是，要执行更改，就必须细分 ThreadGroup ，重写 uncaughtException() ，然后在该线程组中执行您的线程。不过，让我们通过只安装 Thread.UncaughtExceptionHandler ，来看一看 Tiger 的处理方式。
  |
|
使用 UncaughtExceptionHandler 的定制行为
对于 Tiger， Thread 类定义中添加了一个新的公共内部类 UncaughtExceptionHandler ，更完整的名称为 Thread.UncaughtExceptionHandler （其他类访问内部类时需要使用完整名称）。接口的定义是一个方法，如图 7 中所示：
清单 7. UncaughtExceptionHandler 的定义
public interface Thread.UncaughtExceptionHandler {
public void uncaughtException(Thread, Throwable);
}
|
您可能没有注意到，清单 7 中的方法与我们前面重写的 ThreadGroup 的方法相同。实际上，现在由 ThreadGroup 类实现该接口。
新的内部类可以帮助我们了解下列两对新方法，并有助于我们在 Thread 中使用它们：
-
getUncaughtExceptionHandler()和setUncaughtExceptionHandler()。 -
getDefaultUncaughtExceptionHandler()和setDefaultUncaughtExceptionHandler()。
第一对方法是 getUncaughtExceptionHandler() 和 setUncaughtExceptionHandler() ，它们允许您为当前线程及其后代定制行为，从而允许二十或更多的线程拥有自己的定制行为。不过，您更可能使用第二对方法 getDefaultUncaughtExceptionHandler() 和 setDefaultUncaughtExceptionHandler() 。如果使用第二对方法设置默认处理程序，那么没有自己的异常处理程序的所有线程都将使用默认处理程序。
听起来好像很简单。为了进行说明，清单 8 转换了 清单 3 中的 ThreadGroup 友好的程序，使用新的 UncaughtExceptionHandler 接口：
清单 8. UncaughtExceptionHandler 示例
public class HandlerDump {
public static void main(String args[]) throws Exception {
Thread.UncaughtExceptionHandler handler = new LoggingThreadGroup("Logger");
Thread.currentThread().setUncaughtExceptionHandler(handler);
System.out.println(1 / 0);
}
}
|
该程序只是将 LoggingThreadGroup 重用为 UncaughtExceptionHandler ，并没有创建新的处理程序实现。请注意，与原来的代码相比，新代码要简洁得多。
| |
|
其他线程更改
Thread 类不仅支持使用 Tiger 添加的未捕获异常处理程序，它还支持使用 getAllStackTraces() 获得所有有效线程的堆栈跟踪，或者支持使用 getStackTrace() 来只获得当前线程的堆栈跟踪。这两种堆栈跟踪都返回类型为 java.lang.StackTraceElement 的对象， java.lang.StackTraceElement 是 Java 1.4 平台中添加的一个类，它可以让您生成自己的堆栈跟踪。同时，Java 5 平台新添加的功能是一个惟一线程标识符（可以使用 getId() 获得该标识符）和一个新的 Thread.State 类，以及与该类相关的 getThreadState() 方法。最后一个线程更改是一个状态枚举表，该表是用来监视系统状态，而不是用来同步状态的。
| |
|
结束语
像添加未捕获的异常处理程序这样的简单库更改，可以极大地增加原代码的可理解性。虽然在线程组级别上，新的库代码的功能与原来库代码的 相同，但新模型中的易用性和灵活性远远超出了将代码调整为更新的方式所需的时间。当然，老方法仍然可以使用，但最好将代码更新为最新的库功能。