And you'll end up with a highly user hostile application.

The way to go about it is something like:

private void somethingLong(String arg) {
    assert EventQueue.isDispatchThread(); // In EDT
    Thread thread = new Thread(new Runnable() {
            public void run() {
                // Outside EDT
                String result;
                try {
                    Thread.sleep(3000);
                    result = "done: ";
                } catch (java.lang.InterruptedException exc) {
                    result = "punt: ";
                }
                setStatusLater(result+arg);
            }
    }), "Something long");
    thread.setPriority(Thread.NORM_PRIORITY); // 1 less than EDT
    thread.setDaemon(true);
    thread.start();
}
private void setStatus(String message) {
    assert !EventQueue.isDispatchThread(); // Outside EDT
    // If we call this repeatedly the GUI wont have a fit.
    synchronized (this) {
        statusMessage = message;
    }
    EventQueue.invokeLater(new Runnable() {
            public void run() {
                // In EDT
                final String statusMessage;
                synchronized (this) {
                    statusMessage = this.statusMessage;
                }
                statusLabel.setText(statusMessage);
            }
    });
}

You can do better by using the thread pooling of java.util.concurrent,
but that's a bit advanced and makes little difference. Also you can see
if you've already fired off an invokeLater before queueing up more to do
the same. Sometimes callbacks should be throttled - no point in updating
the status for every single line of file read, but it should be up to
date. There's also SwingWorker in Java SE 6.0 and on dev.java.net which
suits some people.

Tom Hawtin