java.lang.Object
   EDU.oswego.cs.dl.util.concurrent.ThreadFactoryUser
      EDU.oswego.cs.dl.util.concurrent.misc.SwingWorker

All Implemented Interfaces:
    Runnable

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");
    status.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
    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")) {
          start.setText("Stop");
          status.setText("Working...");
          worker = new DemoSwingWorker(TIMEOUT);
          worker.start();
        } else {
          worker.interrupt();
        }
      }
    });
  }

  private class DemoSwingWorker extends SwingWorker {
    private static final java.util.Random RAND = new java.util.Random();
    public DemoSwingWorker(long msecs) {
      super(msecs);
    }
    protected Object construct() throws InterruptedException {
      // Take a random nap. If we oversleep, the worker times out.
      Thread.sleep(RAND.nextInt(2*TIMEOUT));
      return "Success";
    }
    protected void finished() {
      start.setText("Start");
      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) {
          status.setText("Interrupted.");
        } else {
          status.setText("Exception: " + ex);
        }
      }
      catch (InterruptedException ex) {
        // event-dispatch thread won't be interrupted 
        throw new IllegalStateException(ex+"");
      }
    }
  }
}

author: Joseph - Bowbeer

author: Hans - Muller

version: 3.0 -

[ Introduction to this package. ]

 public SwingWorker() 
{
        this(FACTORY, 0);
}

 public SwingWorker(long msecs) 
{
        this(FACTORY, msecs);
}

 protected SwingWorker(ThreadFactory factory,
    long msecs) 
{
        setThreadFactory(factory);
        if (msecs <  0) {
            throw new IllegalArgumentException("timeout="+msecs);
        }
        timeout = msecs;
}

 abstract protected Object construct() throws Exception
Computes the value to be returned by the get method.

 protected  void finished() 
{

}

 public Object get() throws InterruptedException, InvocationTargetException 
{
        return result.get();
}

 public InvocationTargetException getException() 
{
        return result.getException();
}

 public long getTimeout() 
{
        return timeout;
}

 public synchronized  void interrupt() 
{
        if (thread != null) {
            /* Try-catch is workaround for JDK1.2 applet security bug.
               On some platforms, a security exception is thrown if an
               applet interrupts a thread that is no longer alive. */
            try { thread.interrupt(); } catch (Exception ex) { }
        }
        result.setException(new InterruptedException());
}

 public boolean isReady() 
{
        return result.isReady();
}

 public  void run() 
{
        Callable function = new Callable() {
            public Object call() throws Exception {
                return construct();
            }
        };
        Runnable doFinished = new Runnable() {
            public void run() {
                finished();
            }
        };
        /* Convert to TimedCallable if timeout is specified. */
        long msecs = getTimeout();
        if (msecs != 0) {
            TimedCallable tc = new TimedCallable(function, msecs);
            tc.setThreadFactory(getThreadFactory());
            function = tc;
        }
        result.setter(function).run();
        SwingUtilities.invokeLater(doFinished);
}

 public synchronized  void start() 
{
        if (thread == null) {
            thread = getThreadFactory().newThread(this);
        }
        thread.start();
}

 public Object timedGet(long msecs) throws TimeoutException, InterruptedException, InvocationTargetException 
{
        return result.timedGet(msecs);
}