SwingWorker

SwingWorker is a popular utility class developed by Sun Microsystems for the Swing library of the Java programming language. SwingWorker enables proper use of the event dispatching thread. As of Java 6, SwingWorker is included in the JRE.

Several incompatible, unofficial, versions of SwingWorker were produced from 1998 to 2006, and care must be taken to avoid the abundant documentation on these versions predating Java 6.

Contents

Usage in Java 6.0

The event dispatching thread problem

SwingWorker is useful when a time-consuming task has to be performed following a user-interaction event (for example, parsing a huge XML File, on pressing a JButton). The most straightforward way to do it is :

  private Document doc;
  ...
  JButton button = new JButton("Open XML");
  button.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
        doc = loadXML();
     }
  });

This will work, but unfortunately, the loadXML() method will be called in the same thread as the main Swing thread (the Event dispatching thread), so if the method needs time to perform, the GUI will freeze during this time.

SwingWorker solution

This problem is not specific to Java, but common to many GUI models. SwingWorker proposes a way to solve it by performing the time-consuming task on another background thread, keeping the GUI responsive during this time.

Creating the worker

The following code defines the SwingWorker, which encapsulates the loadXML() method call :

 SwingWorker worker = new SwingWorker<Document, Void>() {
    public Document doInBackground() {
        Document intDoc = loadXML();
        return intDoc;
    }
 };

Worker execution

Execution is started by using the SwingWorker.execute() method.

Retrieving the result

The result can be retrieved by using the SwingWorker.get() method.

As calling get() on the Event Dispatch Thread blocks all events, including repaints, from being processed until the task completes, one must avoid calling it before the lengthy operation has finished. There are two ways to retrieve the result after the task completion :

 private Document doc;
 ...
 SwingWorker<Document, Void> worker = new SwingWorker<Document, Void>() {
    public Document doInBackground() {
        Document intDoc = loadXML();
        return intDoc;
    }
    public void done() {
        try {
            doc = get();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        } catch (ExecutionException ex) {
            ex.printStackTrace();
        }
    }
 }

Complete Worker example

  private Document doc;
  ...
  JButton button = new JButton("Open XML");
  button.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
       SwingWorker<Document, Void> worker = 
          new SwingWorker<Document, Void>() {
 
          public Document doInBackground() {
            Document intDoc = loadXML();
            return intDoc;
          }
          public void done() {
            try {
               doc = get();
            } catch (InterruptedException ex) {
               ex.printStackTrace();
            } catch (ExecutionException ex) {
               ex.printStackTrace();
            }
          }
       };
       worker.execute();
     }
  });

Usage before Java 6.0

SwingWorker has only been part of JSE since Java 6.0. Sun has released versions to be used with earlier JDKs, although they were unofficial versions which were not part of the J2SE and were not mentioned in the standard library documentation[1]. The most recent of these versions dates from 2003 and is often referred to as SwingWorker version 3.[2] Unfortunately, the JDK 6.0 SwingWorker and the Version 3 SwingWorker use different method names and are not compatible. The backport version (see below) is now recommended for pre-Java 6 usage.

An example for instantiating SwingWorker 3 is shown below:

	SwingWorker worker = new SwingWorker() {
	    public Object construct() {
	    	... //add the code for the background thread
	    }
	    public void finished() {
		... //code that you add here will run in the UI thread
	    }
 
	};
	worker.start();  //Start the background thread

The start() method executes the code added in the construct() method in a separate thread. To be alerted when the background thread finishes, one only needs to override the finished() method. The construct() method can return a result which can later be retrieved using SwingWorker's get() method.

Backport of the Java 6 SwingWorker

A backport of the Java 6 SwingWorker to Java 5 has been available at https://swingworker.dev.java.net/ since March 2007. Apart from the package name ( org.jdesktop.swingworker ), it is compatible with the Java 6 SwingWorker.

References

  1. ^ See the javax.swing package-summary before and after J2SE 6.0. Also notice that there is no SwingWorker class listed in the index pages of the documentation, until version 6.0: [1], [2].
  2. ^ You can download it here.

See also

External links