Catching all possible exceptions in gui thread

Question

Hi,
I have such a problem: I am developing Swing app and sometimes it crashes by throwing an Exception which I don't catch. The effect is that this exception prints stack trace on System.err but user is not notified and wonders what is happening... I would prefer to show custom ErrorDialog with stacktrace.
I am searching for simple and effective way to catch every possible exception thrown from within any library. I think of a few ways from which everyone has some disadvantages.
The ideal way would be replacing AWT event queue dispatcher so I could process every GUI event inside try { } catch (Exception e) {} block. That would be a good place to catch all exceptions. Unfortunately I don't know if it is possible.
For now I am trying such a solution:
I start background thread together with main app. Then I redirect System.err and System.out streams to PipedStream connected to this background thread. This thread can analyze anything that is going to System.err and maybe recognize potential exception stacktraces. Then it can notify main thread of an exception. But it is not ideal as I have to parse the stream and it can always be not ideal in exception recognition. And the code is quite costly.
Do you have any ideas, had similar problems?

Answer 1

But how can I cause GUI thread to run in my thread
group? As I suppose GUI thread is started by JVM and
is something separate from my code - I can get a
reference to GUI thread but don't know how to
manipulate or replace it...One alternative is to completely separate the GUI code from your code.
Your code, which is wrapped in appropriate try/catch blocks, runs on its own thread and does its own processing. When it's done with that processing, it queues the results on the event thread for display. If an exception occurs during your processing, then you queue something that notifies the GUI.
The simplest way to implement this is to spawn a new thread for each operation. The Runnable that you give to that thread looks like the following:
public MyOperationClass implements Runnable
    public void run()
        try
            // do your exception-generating code here
            SwingUtilities.invokeLater( new MyGUIUpdateClass(param1, param2));
        catch (Exception e)
            SwingUtilities.invokeLater(new MyExceptionReporter(e));
}This is only a bare-bones solution (and hasn't been compiled). Since it separates the GUI from actual processing, you'll probably want to display a wait cursor while the processing thread is doing its thing. You'll probably end up implementing a class that implements this pattern. You may also want to create a producer-consumer thread, so that the user won't invoke, say, a dozen different operations at once.
However, this sort of code is absolutely essential to Swing programming. Most apps do extensive non-GUI processing, such as database queries. If you run such queries in the GUI thread, your GUI will freeze.
Sun has named this pattern "SwingWorker", although I don't think they've fleshed it out very fully: http://java.sun.com/products/jfc/tsc/articles/threads/threads2.html