Suggestions for catching runtime in run function

Hi,
I'm new to thread programming, and am kind of working on a monkey see monkey do approach.
I have a reasonably sized program that runs multiple threads, and am wondering how to catch the runtime exceptions.
The code below catches the runtime error and displays the message in a gui. I'm running the program in eclipse, and have noticed that when the dialog box is closed, the process continues to run. How should the program be modified to stop running when the exception dialog is closed?
I thought that adding Thread.currentThread().interrupt(); to the close action listener would do the trick, but the process is still running...

Cheers,
John

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.PrintWriter;
import java.io.StringWriter;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextPane;
import javax.swing.SwingUtilities;

public class ThreadExceptionHandler implements Runnable{
    /* (non-Javadoc)
     * @see java.lang.Runnable#run()
     */
    @SuppressWarnings( "null" )
    @Override
    public void run()
    {
        System.out.printf( "  In thread %s, I'm going to throw an error\n", Thread.currentThread().getName() );
        try {
            String t = null;
            int sl = t.length();
            System.out.printf( "Length is %d", sl );
        } catch (Throwable e) {
            /* 
             * The options are
             *     - log the exception and continue running
             *     - log the exception and restart the worker thread
             *     - log the exception and unload the offending plug-in
             */
            final String thrdName = Thread.currentThread().getName();
            final boolean isModal = false;
            ExceptionDialog exd = new ExceptionDialog( thrdName, e, isModal );
            /*
             * Here's a good place to do some shutdown activities
             */
            exd.center(exd);
            exd.setVisible( true );
        } 
        
        System.out.printf( "  Exiting thread %s\n", Thread.currentThread().getName() );
        
    }
    public static void main(String[] args) throws Exception {
        System.out.printf( "In main, thread %s\n", Thread.currentThread().getName() );
        ThreadExceptionHandler t = new ThreadExceptionHandler();
        SwingUtilities.invokeLater( t );
        System.out.printf( "Exiting main, thread %s\n", Thread.currentThread().getName() );
    }
    /**
     * This dialog will present the details of a throwable exception to a user.
     */
    public static class ExceptionDialog extends JDialog {
        private static final long serialVersionUID = 1L;
        public ExceptionDialog(String aThrdName, final Throwable aExcptn, boolean aIsModal) {
            setTitle(aThrdName + " Error");
            setModal(aIsModal);
            setResizable(true);
            final int width = 800, height = 150;
            setPreferredSize(new Dimension(width, height));
            final JPanel contentPane = new JPanel();
            contentPane.setLayout(new BorderLayout());
            contentPane.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
            setContentPane(contentPane);
            JPanel messagePanel = new JPanel();
            messagePanel.setLayout(new BorderLayout());
            contentPane.add(messagePanel, BorderLayout.PAGE_START);
            messagePanel.add(new JLabel(aThrdName + " has been terminated due to an unrecoverable error."), BorderLayout.PAGE_START);
            JLabel errorType = new JLabel(aExcptn.getClass().getSimpleName());
            errorType.setFont(errorType.getFont().deriveFont(Font.PLAIN));
            messagePanel.add(errorType, BorderLayout.CENTER);
            JPanel buttonPanel = new JPanel();
            buttonPanel.setLayout(new FlowLayout(FlowLayout.RIGHT, 10, 0));
            JButton close = new JButton("Close");
            close.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    setVisible(false);
                    Thread.currentThread().interrupt();
                }
            });
            buttonPanel.add(close);
            final JButton details = new JButton("Details");
            details.addActionListener(new ActionListener() {
                /**
                 * When the user clicks the details button, add the stack trace
                 * to the dialog and disable the details button.
                 */
                public void actionPerformed(ActionEvent evt) {
                    JPanel detailsPanel = new JPanel();
                    detailsPanel.setLayout(new BorderLayout());
                    detailsPanel.setBorder(BorderFactory.createEmptyBorder(10, 0, 10, 0));
                    contentPane.add(detailsPanel, BorderLayout.CENTER);
                    JLabel detailsLabel = new JLabel("Error Details");
                    detailsPanel.add(detailsLabel, BorderLayout.PAGE_START);
                    /*
                     * This special construction of a JTextPane prevents line
                     * wrapping, allowing the scrollpane to do its job
                     * horizontally.
                     */
                    final JTextPane detailsText = new JTextPane() {
                        private static final long serialVersionUID = 1L;
                        public boolean getScrollableTracksViewportWidth() {
                            return (getSize().width < getParent().getSize().width);
                        }
                        public void setSize(Dimension d) {
                            if(d.width < getParent().getSize().width) {
                                d.width = getParent().getSize().width;
                            }
                            super.setSize(d);
                        }
                    };
                    detailsText.setEditable(false);
                    /* Uncomment this line if you don't like the white background of the text pane */
                    //detailsText.setBackground(contentPane.getBackground());
                    // Print the stack trace to a string...
                    StringWriter sw = new StringWriter();
                    PrintWriter pw = new PrintWriter(sw, true);
                    aExcptn.printStackTrace(pw);
                    pw.flush();
                    sw.flush();
                    detailsText.setText(sw.toString());
                    JScrollPane scrollPane = new JScrollPane(detailsText);
                    detailsPanel.add(scrollPane, BorderLayout.CENTER);
                    details.setEnabled(false);
                    // expand the dialog size to make room for the details
                    setPreferredSize(new Dimension(width, height+200));
                    pack();
                }
            });
            buttonPanel.add(details);
            contentPane.add(buttonPanel, BorderLayout.PAGE_END);
            pack();
        }
        /**
         * Utility method for centering swing components onscreen.
         */
        public void center(Component component) {
            Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
            Dimension frameSize = component.getSize();
            if(frameSize.height > screenSize.height) {
                frameSize.height = screenSize.height;
            }
            if(frameSize.width > screenSize.width) {
                frameSize.width = screenSize.width;
            }
            component.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2);
        }
    }
}

Your class 'ThreadExceptionHandler' is just a Runnable and not a Thread. You are not starting a thread anywhere. By calling SwingUtilities.invokeLater, you are just adding a piece of Runnable to be placed in the EDT queue (Swing's Event Thread). The process continues to be running because, in the close button, you only make the dialog invisible. Instead, call dispose() on the dialog to close it. Then the process will end.

Thanks Ranganathan.