Question

How can I know, whether I should make a function call within GUI thread.

if (SwingUtilities.isEventDispatchThread()) {
    // ...
} else {

    SwingUtilities.invokeLater(new Runnable() {
        @Override
        public void run() {
            // ...
        }
    });
}

For example

// Should I call this within GUI thread?
jTable.getModel().setValueAt(...

Or

// Should I call this within GUI thread?
jComboBox.showPopup();

As I know, making operation in incorrect thread, may yield problem which is not easy to be detected. Hence, quite difficult for me to verify whether I am doing the correct stuff.

Currently, what I am doing is, If I am not sure, I will just call them in GUI thread

Not sure whether this is the best way, or there is a reliable way to figure out?

Answer 1

If you really need some ultra-generic thing “invoke ASAP” functionality, a helper like this is useful:

void invokeAsSoonAsPossible(Runnable action) {
    if (SwingUtilities.isEventDispatchThread())
        action.run();
    else SwingUtilities.invokeLater(action);
}

// Usage:
invokeAsSoonAsPossible(new Runnable(){
    @Override
    public void run() {
        jTable.getModel().setValueAt(...
    }
});

But my experience tells me that it’s a far better strategy to structure and document your code so that it gets easier to keep track of what is running where. If you’ve got a public method in a class which should be run on the EDT, JavaDoc is a good friend:

/**
 * Blah blah blah, describe the method's purpose.
 * <p>
 * <strong>Note:</strong> This method should always be 
 * invoked on the Swing event dispatch thread.
 */
public Pony calulateValue() {
    // go ahead and touch the components any way you please
}

You can also add an assertion in EDT-only methods as a kind of executable documentation:

assert SwingUtilities.isEventDispatchThread();

In short: If you have a hard time keeping track of which thread you’re in, your code is probably so crufty that you have a hard time keeping track of anything, and you should worry about refactoring your code, not which thread you’re on.