当前位置导航:炫浪网>>网络学院>>编程开发>>JAVA教程>>Java进阶

驯服 Tiger:线程中的默认异常处理


  跟踪无法预期的运行时异常可能是一件又慢又费力的事情,只获得默认线程名称和堆栈跟踪通常是不够的。在驯服 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);
     }
    });
   }
  }
  
  发生运行时异常时,可能要做许多工作来更改发生的问题。该代码的大部分都是 Logging Handler,但是,要执行更改,就必须细分 ThreadGroup,重写 uncaughtException(),然后在该线程组中执行您的线程。不过,让我们通过只安装 Thread.UncaughtExceptionHandler,来看
相关内容
赞助商链接