Editing Event dispatching thread (section)

==Submitting user code to the EDT==

There are various solutions for submitting code to the EDT and performing lengthy tasks without blocking the loop.

===Component event handlers (listeners)===
GUI components support the lists of callbacks, called Listeners, which are typically populated when the components are created. EDT executes the listeners when user excitates the components somehow (button is clicked, mouse is moved, item is selected, focus is lost, component resized and so on.)

=== Timer ===
For short tasks that must access/modify GUI periodically or at specific time, <code>javax.swing.Timer</code> is used. It can be considered as an invisible GUI component, whose listeners are registered to fire at specific time(s).

Equivalents
* <code>System.Windows.Forms.Timer</code> - [[.NET Framework]]
* <code>flash.utils.Timer</code> - [[Adobe Flash]]

=== Requests from other threads ===

Other application threads can pass some code to be executed in the event dispatching thread by means of {{Javadoc:SE|javax/swing|SwingUtilities|module=java.desktop}} helper classes (or {{Javadoc:SE|java/awt|EventQueue|module=java.desktop}} if you are doing [[Abstract Window Toolkit|AWT]]). The submitted code must be wrapped with a {{Javadoc:SE|java/lang|Runnable}} object. Two methods of these classes allow:
* synchronous code execution ({{Javadoc:SE|member=invokeAndWait(Runnable)|javax/swing|SwingUtilities|invokeAndWait(java.lang.Runnable)|module=java.desktop}} or {{Javadoc:SE|member=invokeAndWait(Runnable)|java/awt|EventQueue|invokeAndWait(java.lang.Runnable)|module=java.desktop}})
* and asynchronous code execution ({{Javadoc:SE|member=invokeLater(Runnable)|javax/swing|SwingUtilities|invokeLater(java.lang.Runnable)|module=java.desktop}} or {{Javadoc:SE|member=invokeLater(Runnable)|java/awt|EventQueue|invokeLater(java.lang.Runnable)|module=java.desktop}})
from the event dispatching thread.

The method <code>invokeAndWait()</code> should never be called from the event dispatching thread&mdash;it will throw an [[Exception handling|exception]]. The method {{Javadoc:SE|javax/swing|SwingUtilities|isEventDispatchThread()|module=java.desktop}} or {{Javadoc:SE|java/awt|EventQueue|isDispatchThread()|module=java.desktop}} can be called to determine if the current thread is the event dispatching thread.

The code supplied by means of the <code>invokeLater</code> and <code>invokeAndWait</code> to the EDT must be as quick as possible to prevent freezing. They are normally intended to deliver the result of a lengthy computation to the GUI (user).

=== Worker design pattern ===
Both execution of a task in another thread and presenting the results in the EDT can be combined by means of ''[[SwingWorker|worker design pattern]]''. The <code>[[SwingWorker|javax.swing.SwingWorker]]</code> class, developed by [[Sun Microsystems]], is an implementation of the worker design pattern, and as of Java 6 is part of standard Swing distribution. SwingWorker is normally invoked from EDT-executed event Listener to perform a lengthy task in order not to block the EDT.

====Samples====
<syntaxhighlight lang="java">
SwingWorker<Document, Void> worker = new SwingWorker<Document, Void>() {
    public Document doInBackground() throws IOException {
        return loadXML(); // heavy task
    }
    
    public void done() {
        try {
            Document doc = get();
            display(doc);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
};
worker.execute();
</syntaxhighlight>

If you use [[Groovy (programming language)|Groovy]] and <code>groovy.swing.SwingBuilder</code>, you can use <code>doLater()</code>, <code>doOutside()</code>, and <code>edt()</code>. Then you can write it more simply like this:

<syntaxhighlight lang="groovy">
doOutside {
    def doc = loadXML() // heavy task
    edt { display(doc) }
}
</syntaxhighlight>

====Equivalents====
* <code>System.ComponentModel.BackgroundWorker</code> - [[.NET Framework]]
* <code>flash.system.Worker</code> - [[Adobe Flash]]
* <code>android.os.AsyncTask</code> - [[Android (operating system)|Android]]

===Modal execution===
SwingWorker is normally created for a lengthy tasks by EDT while handling callback (Listener) events. Spawning a worker thread, EDT proceeds handling current message without waiting the worker to complete. [https://stackoverflow.com/questions/3028842/how-can-swing-dialogs-even-work Often, this is not desirable.]

Often, your EDT handles a GUI component action, which demands the user to make a choice by means of another dialog, like JFileChooser, which pops up, stays responsive while user picks its option and action proceeds with selected file only after "OK" button is pressed. You see, this takes time (user responds in matter of seconds) and you need a responsive GUI (the messages are still pumped in EDT) during all this time while EDT is blocking (it does not handle newer, e.g. JFileChooser, messages in the queue before the dialog is closed and current component action is finished). The vicious cycle is broken through EDT entering a new message loop, which dispatches the messages as per normal until "modal dialog is over" arrives and normal message processing resumes from the blocked position in the component action.

The open source '''[http://foxtrot.sourceforge.net/docs/worker.php Foxtrot]''' project emulates the Swing message loop pumping to provide the "synchronous" execution mechanism for arbitrary user tasks, which proceeds only after the worker completes the task.

<syntaxhighlight lang="java">
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        button.setText("Sleeping...");

        String text = null;
        try {
            text = (String) Worker.post(new Task() {
                public Object run() throws Exception {
                    Thread.sleep(10000);
                    return "Slept !";
                }
            });
        } catch (Exception x)...

        button.setText(text);

        somethingElse();
    }
});
</syntaxhighlight>

Since Java 1.7, Java provides '''standard''' solution for custom '''secondary message loops''' by exposing ''createSecondaryLoop''() in system ''EventQueue''().