Home » concurrent-sources » EDU.oswego.cs.dl.util.concurrent.misc » [javadoc | source]
abstract public class: SwingWorker [javadoc | source]

All Implemented Interfaces:

An abstract class that you subclass to perform GUI-related work in a dedicated thread.

This class was adapted from the SwingWorker written by Hans Muller and presented in "Using a Swing Worker Thread" in the Swing Connection - http://java.sun.com/products/jfc/tsc/articles/threads/threads2.html

A closely related version of this class is described in "The Last Word in Swing Threads" in the Swing Connection - http://java.sun.com/products/jfc/tsc/articles/threads/threads3.html

This SwingWorker is a ThreadFactoryUser and implements Runnable. The default thread factory creates low-priority worker threads. A special constructor is provided for enabling a timeout. When the timeout expires, the worker thread is interrupted.

Note: Using a timeout of Long.MAX_VALUE will not impose a timeout but will create an additional thread of control that will respond to an interrupt even if the construct implementation ignores them.

Sample Usage

import EDU.oswego.cs.dl.util.concurrent.TimeoutException;
import EDU.oswego.cs.dl.util.concurrent.misc.SwingWorker;

public class SwingWorkerDemo extends javax.swing.JApplet {

  private static final int TIMEOUT = 5000; // 5 seconds
  private javax.swing.JLabel status;
  private javax.swing.JButton start;
  private SwingWorker worker;

  public SwingWorkerDemo() {
    status = new javax.swing.JLabel("Ready");
    getContentPane().add(status, java.awt.BorderLayout.CENTER);
    start = new javax.swing.JButton("Start");
    getContentPane().add(start, java.awt.BorderLayout.SOUTH);

    start.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(java.awt.event.ActionEvent evt) {
        if (start.getText().equals("Start")) {
          worker = new DemoSwingWorker(TIMEOUT);
        } else {

  private class DemoSwingWorker extends SwingWorker {
    private static final java.util.Random RAND = new java.util.Random();
    public DemoSwingWorker(long msecs) {
    protected Object construct() throws InterruptedException {
      // Take a random nap. If we oversleep, the worker times out.
      return "Success";
    protected void finished() {
      try {
        Object result = get();
        status.setText((String) result);
      catch (java.lang.reflect.InvocationTargetException e) {
        Throwable ex = e.getTargetException();
        if (ex instanceof TimeoutException) {
          status.setText("Timed out.");
        } else if (ex instanceof InterruptedException) {
        } else {
          status.setText("Exception: " + ex);
      catch (InterruptedException ex) {
        // event-dispatch thread won't be interrupted 
        throw new IllegalStateException(ex+"");
Fields inherited from EDU.oswego.cs.dl.util.concurrent.ThreadFactoryUser:
 public SwingWorker() 
 public SwingWorker(long msecs) 
 protected SwingWorker(ThreadFactory factory,
    long msecs) 
    Creates new SwingWorker with specified thread factory and timeout.
    factory - factory for worker threads.
    msecs - timeout in milliseconds, or 0 for no time limit.
Method from EDU.oswego.cs.dl.util.concurrent.misc.SwingWorker Summary:
construct,   finished,   get,   getException,   getTimeout,   interrupt,   isReady,   run,   start,   timedGet
Methods from EDU.oswego.cs.dl.util.concurrent.ThreadFactoryUser:
getThreadFactory,   setThreadFactory
Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from EDU.oswego.cs.dl.util.concurrent.misc.SwingWorker Detail:
 abstract protected Object construct() throws Exception
    Computes the value to be returned by the get method.
 protected  void finished() 
    Called on the event dispatching thread (not on the worker thread) after the construct method has returned.
 public Object get() throws InterruptedException, InvocationTargetException 
    Return the value created by the construct method, waiting if necessary until it is ready.
 public InvocationTargetException getException() 
    Get the exception, or null if there isn't one (yet). This does not wait until the worker is ready, so should ordinarily only be called if you know it is.
 public long getTimeout() 
    Returns timeout period in milliseconds. Timeout is the maximum time to wait for worker to complete. There is no time limit if timeout is 0 (default).
 public synchronized  void interrupt() 
    Stops the worker and sets the exception to InterruptedException.
 public boolean isReady() 
    Return whether the get method is ready to return a value.
 public  void run() 
    Calls the construct method to compute the result, and then invokes the finished method on the event dispatch thread.
 public synchronized  void start() 
    Starts the worker thread.
 public Object timedGet(long msecs) throws TimeoutException, InterruptedException, InvocationTargetException 
    Wait at most msecs to access the constructed result.