馴服Tiger: 線程中的默認異常處理

雖然我們不想創建在無法預期時拋出運行時異常的程序，但這種情況還是會發生——尤其是第一次運行復雜程序時。通常是使用默認行為、打印堆棧溢出和結束線程的生命來處理這些異常。

從哪裡發現默認行為？每個線程都屬於一個由 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() 方法。最後一個線程更改是一個狀態枚舉表，該表是用來監視系統狀態，而不是用來同步狀態的。

結束語

像添加未捕獲的異常處理程序這樣的簡單庫更改，可以極大地增加原代碼的可理解性。雖然在線程組級別上，新的庫代碼的功能與原來庫代碼的相同，但新模型中的易用性和靈活性遠遠超出了將代碼調整為更新的方式所需的時間。當然，老方法仍然可以使用，但最好將代碼更新為最新的庫功能。

本文配套源碼