## EDU.oswego.cs.dl.util.concurrent.misc
Class SwingWorker

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

All Implemented Interfaces:
  java.lang.Runnable

public abstract class SwingWorker
extends ThreadFactoryUser
implements java.lang.Runnable

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");
         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+"");
           }
         }
       }
     }

Constructor Summary
`SwingWorker()` Creates new SwingWorker with no timeout.
`SwingWorker(long msecs)` Creates new SwingWorker with specified timeout.

Method Summary
`java.lang.Object` `get()` Return the value created by the `construct` method, waiting if necessary until it is ready.
`java.lang.reflect.InvocationTargetException` `getException()` Get the exception, or null if there isn't one (yet).
`long` `getTimeout()` Returns timeout period in milliseconds.
`void` `interrupt()` Stops the worker and sets the exception to InterruptedException.
`boolean` `isReady()` Return whether the `get` method is ready to return a value.
`void` `run()` Calls the `construct` method to compute the result, and then invokes the `finished` method on the event dispatch thread.
`void` `start()` Starts the worker thread.
`java.lang.Object` `timedGet(long msecs)` Wait at most msecs to access the constructed result.

Methods inherited from class EDU.oswego.cs.dl.util.concurrent.ThreadFactoryUser
`getThreadFactory, setThreadFactory`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### SwingWorker

    public SwingWorker()

  Creates new SwingWorker with no timeout.

### SwingWorker

    public SwingWorker(long msecs)

  Creates new SwingWorker with specified timeout.

Parameters:
  `msecs` - timeout in milliseconds, or `0` for no time limit.

Method Detail

### getTimeout

    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).

### run

    public void run()

  Calls the `construct` method to compute the result, and then invokes the `finished` method on the event dispatch thread.

  Specified by:
    `run` in interface `java.lang.Runnable`

### start

    public void start()

  Starts the worker thread.

### interrupt

    public void interrupt()

  Stops the worker and sets the exception to InterruptedException.

### get

    public java.lang.Object get()
                         throws java.lang.InterruptedException,
                                java.lang.reflect.InvocationTargetException

  Return the value created by the `construct` method, waiting if necessary until it is ready.

  Returns:
    the value created by the `construct` method
  Throws:
    `java.lang.InterruptedException` - if current thread was interrupted
    `java.lang.reflect.InvocationTargetException` - if the constructing thread encountered an exception or was interrupted.

### timedGet

    public java.lang.Object timedGet(long msecs)
                              throws TimeoutException,
                                     java.lang.InterruptedException,
                                     java.lang.reflect.InvocationTargetException

  Wait at most msecs to access the constructed result.

  Returns:
    current value
  Throws:
    `TimeoutException` - if not ready after msecs
    `java.lang.InterruptedException` - if current thread has been interrupted
    `java.lang.reflect.InvocationTargetException` - if the constructing thread encountered an exception or was interrupted.

### getException

    public java.lang.reflect.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.

  Returns:
    the exception encountered by the `construct` method wrapped in an InvocationTargetException

### isReady

    public boolean isReady()

  Return whether the `get` method is ready to return a value.

  Returns:
    true if a value or exception has been set. else false