Java 处理在单独线程中抛出的异常的最佳方法是什么？

我正在从事一个J2ME项目，该项目为许多任务（如下载HTTP内容）生成工作线程。基本的线程布局与大多数java应用程序类似——有一个主UI线程和派生的工作线程，用于在后台执行任务。我的问题是，处理工作线程中发生的异常的最佳方法是什么

我通常坚持设计原理，即大多数异常应尽可能过滤。当我编写单线程应用程序时，我通常会将异常过滤到UI层，然后在错误对话框中报告给用户。多线程应用程序也有类似的做法吗？对我来说，最直观的方法是捕获Thread.run（）中的异常，然后调用UI线程上的invokeLater在对话框中报告它。我在这里看到的问题是，除了工作线程过早消亡之外，这种方法并没有真正通知UI线程有错误。可以说，我看不到一种明确的方法可以跨线程抛出异常

谢谢，

---

安迪

你不应该把用户界面代码塞进你的工作人员

/**
 * TWO CHOICES:
 * - Monitor your threads and report errors,
 * - setup a callback to do something.
 */
public class ThreadExceptions {

    /** Demo of {@link RunnableCatch} */
    public static void main(String[] argv) throws InterruptedException {
        final Runnable bad = new NaughtyThread();
        // safe1 doesnt have a callback
        final RunnableCatch safe1 = new RunnableCatch(bad);
        // safe2 DOES have a callback
        final RunnableCatch safe2 = new RunnableCatch(bad, new RunnableCallback() {
            public void handleException(Runnable runnable, Exception exception) {
                System.out.println("Callback handled: " + exception.getMessage());
                exception.printStackTrace();
            }

        });
        final Thread t1 = new Thread(safe1, "myThread");
        final Thread t2 = new Thread(safe2, "myThread");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        if (safe1.getException() != null) {
            System.out.println("thread finished with exceptions");
            safe1.getException().printStackTrace();
        }
        System.out.println("done");
    }


}

/** Throws an exception 50% of the time */
class NaughtyThread implements Runnable {
    public void run() {
        try {
            if (Math.random() > .5) {
                throw new RuntimeException("badness");
            }
        } finally {
            System.out.println("ran");
        }
    }
}

/** Called when an exception occurs */
interface RunnableCallback {
    void handleException(Runnable runnable, Exception exception);
}

/**
 * Catches exceptions thrown by a Runnable,
 * so you can check/view them later and/or
 * deal with them from some callback.
 */
class RunnableCatch implements Runnable {

    /** Proxy we will run */
    private final Runnable _proxy;

    /** Callback, if any */
    private final RunnableCallback _callback;

    /** @guarded-by(this) */
    private Exception _exception;

    public RunnableCatch(final Runnable proxy) {
        this(proxy, null);
    }

    public RunnableCatch(final Runnable proxy, RunnableCallback target) {
        _proxy = proxy;
        _callback = target;
    }

    public void run() {
        try {
            _proxy.run();
        } catch (Exception e) {
            synchronized (this) {
                _exception = e;
            }
            if (_callback != null) {
                _callback.handleException(_proxy, e);
            }
        }
    }

    /** @return any exception that occured, or NULL */
    public synchronized Exception getException() {
        return _exception;
    }
}

---

除了Stuph给出的选项之外，另一个选项是在本地线程中设置异常。如果在清除该异常之前发生另一个异常，则会发生断言。这至少让某人有机会注意到异常并对其进行处理。

谢谢Stuph。这更有道理。关于您的示例的一个快速问题是：在分配给_异常的过程中，synchronized（this）块真的是必要的吗？我的印象是对象分配是原子的。