Class SwingWorker<T,V> 
- Type Parameters:
- T- the result type returned by this- SwingWorker's- doInBackgroundand- getmethods
- V- the type used for carrying out intermediate results by this- SwingWorker's- publishand- processmethods
- All Implemented Interfaces:
- Runnable,- Future<T>,- RunnableFuture<T>
SwingWorker is unspecified and should not be relied on.
 When writing a multi-threaded application using Swing, there are two constraints to keep in mind: (refer to Concurrency in Swing for more details):
- Time-consuming tasks should not be run on the Event Dispatch Thread. Otherwise the application becomes unresponsive.
- Swing components should be accessed on the Event Dispatch Thread only.
These constraints mean that a GUI application with time intensive computing needs at least two threads: 1) a thread to perform the lengthy task and 2) the Event Dispatch Thread (EDT) for all GUI-related activities. This involves inter-thread communication which can be tricky to implement.
 SwingWorker is designed for situations where you need to have a long
 running task run in a background thread and provide updates to the UI
 either when done, or while processing.
 Subclasses of SwingWorker must implement
 the doInBackground() method to perform the background computation.
 
Workflow
 There are three threads involved in the life cycle of a
 SwingWorker :
 
- 
 Current thread: The execute()method is called on this thread. It schedulesSwingWorkerfor the execution on a worker thread and returns immediately. One can wait for theSwingWorkerto complete using thegetmethods.
- 
 Worker thread: The doInBackground()method is called on this thread. This is where all background activities should happen. To notifyPropertyChangeListenersabout bound properties changes use thefirePropertyChangeandgetPropertyChangeSupport()methods. By default there are two bound properties available:stateandprogress.
- 
 Event Dispatch Thread: All Swing related activities occur on this thread. SwingWorkerinvokes theprocessanddone()methods and notifies anyPropertyChangeListenerson this thread.
Often, the Current thread is the Event Dispatch Thread.
 Before the doInBackground method is invoked on a worker thread,
 SwingWorker notifies any PropertyChangeListeners about the
 state property change to StateValue.STARTED.  After the
 doInBackground method is finished the done method is
 executed.  Then SwingWorker notifies any PropertyChangeListeners
 about the state property change to StateValue.DONE.
 
 SwingWorker is only designed to be executed once.  Executing a
 SwingWorker more than once will not result in invoking the
 doInBackground method twice.
 
Sample Usage
The following example illustrates the simplest use case. Some processing is done in the background and when done you update a Swing component.
 Say we want to find the "Meaning of Life" and display the result in
 a JLabel.
 
   final JLabel label;
   class MeaningOfLifeFinder extends SwingWorker<String, Object> {
       @Override
       public String doInBackground() {
           return findTheMeaningOfLife();
       }
       @Override
       protected void done() {
           try {
               label.setText(get());
           } catch (Exception ignore) {
           }
       }
   }
   (new MeaningOfLifeFinder()).execute();
 
 The next example is useful in situations where you wish to process data as it is ready on the Event Dispatch Thread.
 Now we want to find the first N prime numbers and display the results in a
 JTextArea.  While this is computing, we want to update our
 progress in a JProgressBar.  Finally, we also want to print
 the prime numbers to System.out.
 
 class PrimeNumbersTask extends
         SwingWorker<List<Integer>, Integer> {
     PrimeNumbersTask(JTextArea textArea, int numbersToFind) {
         //initialize
     }
     @Override
     public List<Integer> doInBackground() {
         while (! enough && ! isCancelled()) {
                 number = nextPrimeNumber();
                 publish(number);
                 setProgress(100 * numbers.size() / numbersToFind);
             }
         }
         return numbers;
     }
     @Override
     protected void process(List<Integer> chunks) {
         for (int number : chunks) {
             textArea.append(number + "\n");
         }
     }
 }
 JTextArea textArea = new JTextArea();
 final JProgressBar progressBar = new JProgressBar(0, 100);
 PrimeNumbersTask task = new PrimeNumbersTask(textArea, N);
 task.addPropertyChangeListener(
     new PropertyChangeListener() {
         public  void propertyChange(PropertyChangeEvent evt) {
             if ("progress".equals(evt.getPropertyName())) {
                 progressBar.setValue((Integer)evt.getNewValue());
             }
         }
     });
 task.execute();
 System.out.println(task.get()); //prints all prime numbers we have got
 
 
 Because SwingWorker implements Runnable, a
 SwingWorker can be submitted to an
 Executor for execution.
- Since:
- 1.6
- 
Nested Class SummaryNested ClassesModifier and TypeClassDescriptionstatic enumValues for thestatebound property.Nested classes/interfaces declared in interface java.util.concurrent.FutureFuture.State
- 
Constructor SummaryConstructors
- 
Method SummaryModifier and TypeMethodDescriptionfinal voidAdds aPropertyChangeListenerto the listener list.final booleancancel(boolean mayInterruptIfRunning) Attempts to cancel execution of this task.protected abstract TComputes a result, or throws an exception if unable to do so.protected voiddone()Executed on the Event Dispatch Thread after thedoInBackgroundmethod is finished.final voidexecute()Schedules thisSwingWorkerfor execution on a worker thread.final voidfirePropertyChange(String propertyName, Object oldValue, Object newValue) Reports a bound property update to any registered listeners.final Tget()Waits if necessary for the computation to complete, and then retrieves its result.final TWaits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.final intReturns theprogressbound property.final PropertyChangeSupportReturns thePropertyChangeSupportfor thisSwingWorker.final SwingWorker.StateValuegetState()Returns theSwingWorkerstate bound property.final booleanReturnstrueif this task was cancelled before it completed normally.final booleanisDone()Returnstrueif this task completed.protected voidReceives data chunks from thepublishmethod asynchronously on the Event Dispatch Thread.protected final voidSends data chunks to theprocess(java.util.List<V>)method.final voidRemoves aPropertyChangeListenerfrom the listener list.final voidrun()Sets thisFutureto the result of computation unless it has been cancelled.protected final voidsetProgress(int progress) Sets theprogressbound property.Methods declared in class java.lang.Objectclone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitMethods declared in interface java.util.concurrent.FutureexceptionNow, resultNow, state
- 
Constructor Details- 
SwingWorkerpublic SwingWorker()Constructs thisSwingWorker.
 
- 
- 
Method Details- 
doInBackground
- 
runpublic final void run()Sets thisFutureto the result of computation unless it has been cancelled.- Specified by:
- runin interface- Runnable
- Specified by:
- runin interface- RunnableFuture<T>
 
- 
publishSends data chunks to theprocess(java.util.List<V>)method. This method is to be used from inside thedoInBackgroundmethod to deliver intermediate results for processing on the Event Dispatch Thread inside theprocessmethod.Because the processmethod is invoked asynchronously on the Event Dispatch Thread multiple invocations to thepublishmethod might occur before theprocessmethod is executed. For performance purposes all these invocations are coalesced into one invocation with concatenated arguments.For example: publish("1"); publish("2", "3"); publish("4", "5", "6");might result in:process("1", "2", "3", "4", "5", "6")Sample Usage. This code snippet loads some tabular data and updates DefaultTableModelwith it. Note that it safe to mutate the tableModel from inside theprocessmethod because it is invoked on the Event Dispatch Thread.class TableSwingWorker extends SwingWorker<DefaultTableModel, Object[]> { private final DefaultTableModel tableModel; public TableSwingWorker(DefaultTableModel tableModel) { this.tableModel = tableModel; }@Overrideprotected DefaultTableModel doInBackground() throws Exception { for (Object[] row = loadData(); ! isCancelled() && row != null; row = loadData()) { publish((Object[]) row); } return tableModel; }@Overrideprotected void process(List<Object[]> chunks) { for (Object[] row : chunks) { tableModel.addRow(row); } } }- Parameters:
- chunks- intermediate results to process
- See Also:
 
- 
processReceives data chunks from thepublishmethod asynchronously on the Event Dispatch Thread.Please refer to the publish(V...)method for more details.- Parameters:
- chunks- intermediate results to process
- See Also:
 
- 
doneprotected void done()Executed on the Event Dispatch Thread after thedoInBackgroundmethod is finished. The default implementation does nothing. Subclasses may override this method to perform completion actions on the Event Dispatch Thread. Note that you can query status inside the implementation of this method to determine the result of this task or whether this task has been cancelled.- See Also:
 
- 
setProgressprotected final void setProgress(int progress) Sets theprogressbound property. The value should be from 0 to 100.Because PropertyChangeListeners are notified asynchronously on the Event Dispatch Thread multiple invocations to thesetProgressmethod might occur before anyPropertyChangeListenersare invoked. For performance purposes all these invocations are coalesced into one invocation with the last invocation argument only.For example, the following invocations: setProgress(1); setProgress(2); setProgress(3); might result in a singlePropertyChangeListenernotification with the value3.- Parameters:
- progress- the progress value to set
- Throws:
- IllegalArgumentException- is value not from 0 to 100
 
- 
getProgresspublic final int getProgress()Returns theprogressbound property.- Returns:
- the progress bound property.
 
- 
executepublic final void execute()Schedules thisSwingWorkerfor execution on a worker thread. There are a number of worker threads available. In the event all worker threads are busy handling otherSwingWorkersthisSwingWorkeris placed in a waiting queue.Note: SwingWorkeris only designed to be executed once. Executing aSwingWorkermore than once will not result in invoking thedoInBackgroundmethod twice.
- 
cancelpublic final boolean cancel(boolean mayInterruptIfRunning) Attempts to cancel execution of this task. This method has no effect if the task is already completed or cancelled, or could not be cancelled for some other reason. Otherwise, if this task has not started whencancelis called, this task should never run. If the task has already started, then themayInterruptIfRunningparameter determines whether the thread executing this task (when known by the implementation) is interrupted in an attempt to stop the task.The return value from this method does not necessarily indicate whether the task is now cancelled; use Future.isCancelled().- Specified by:
- cancelin interface- Future<T>
- Parameters:
- mayInterruptIfRunning-- trueif the thread executing this task should be interrupted (if the thread is known to the implementation); otherwise, in-progress tasks are allowed to complete
- Returns:
- falseif the task could not be cancelled, typically because it has already completed;- trueotherwise. If two or more threads cause a task to be cancelled, then at least one of them returns- true. Implementations may provide stronger guarantees.
 
- 
isCancelledpublic final boolean isCancelled()Returnstrueif this task was cancelled before it completed normally.- Specified by:
- isCancelledin interface- Future<T>
- Returns:
- trueif this task was cancelled before it completed
 
- 
isDone
- 
getWaits if necessary for the computation to complete, and then retrieves its result.Note: calling geton the Event Dispatch Thread blocks all events, including repaints, from being processed until thisSwingWorkeris complete.When you want the SwingWorkerto block on the Event Dispatch Thread we recommend that you use a modal dialog.For example: class SwingWorkerCompletionWaiter implements PropertyChangeListener { private JDialog dialog; public SwingWorkerCompletionWaiter(JDialog dialog) { this.dialog = dialog; } public void propertyChange(PropertyChangeEvent event) { if ("state".equals(event.getPropertyName()) && SwingWorker.StateValue.DONE == event.getNewValue()) { dialog.setVisible(false); dialog.dispose(); } } } JDialog dialog = new JDialog(owner, true); swingWorker.addPropertyChangeListener( new SwingWorkerCompletionWaiter(dialog)); swingWorker.execute(); //the dialog will be visible until the SwingWorker is done dialog.setVisible(true);- Specified by:
- getin interface- Future<T>
- Returns:
- the computed result
- Throws:
- CancellationException- if the computation was cancelled
- InterruptedException- if the current thread was interrupted while waiting
- ExecutionException- if the computation threw an exception
 
- 
getpublic final T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.Please refer to get()for more details.- Specified by:
- getin interface- Future<T>
- Parameters:
- timeout- the maximum time to wait
- unit- the time unit of the timeout argument
- Returns:
- the computed result
- Throws:
- CancellationException- if the computation was cancelled
- InterruptedException- if the current thread was interrupted while waiting
- ExecutionException- if the computation threw an exception
- TimeoutException- if the wait timed out
 
- 
addPropertyChangeListenerAdds aPropertyChangeListenerto the listener list. The listener is registered for all properties. The same listener object may be added more than once, and will be called as many times as it is added. Iflistenerisnull, no exception is thrown and no action is taken.Note: This is merely a convenience wrapper. All work is delegated to PropertyChangeSupportfromgetPropertyChangeSupport().- Parameters:
- listener- the- PropertyChangeListenerto be added
 
- 
removePropertyChangeListenerRemoves aPropertyChangeListenerfrom the listener list. This removes aPropertyChangeListenerthat was registered for all properties. Iflistenerwas added more than once to the same event source, it will be notified one less time after being removed. Iflistenerisnull, or was never added, no exception is thrown and no action is taken.Note: This is merely a convenience wrapper. All work is delegated to PropertyChangeSupportfromgetPropertyChangeSupport().- Parameters:
- listener- the- PropertyChangeListenerto be removed
 
- 
firePropertyChangeReports a bound property update to any registered listeners. No event is fired ifoldandneware equal and non-null.This SwingWorkerwill be the source for any generated events.When called off the Event Dispatch Thread PropertyChangeListenersare notified asynchronously on the Event Dispatch Thread.Note: This is merely a convenience wrapper. All work is delegated to PropertyChangeSupportfromgetPropertyChangeSupport().- Parameters:
- propertyName- the programmatic name of the property that was changed
- oldValue- the old value of the property
- newValue- the new value of the property
 
- 
getPropertyChangeSupportReturns thePropertyChangeSupportfor thisSwingWorker. This method is used when flexible access to bound properties support is needed.This SwingWorkerwill be the source for any generated events.Note: The returned PropertyChangeSupportnotifies anyPropertyChangeListeners asynchronously on the Event Dispatch Thread in the event thatfirePropertyChangeorfireIndexedPropertyChangeare called off the Event Dispatch Thread.- Returns:
- PropertyChangeSupportfor this- SwingWorker
 
- 
getStateReturns theSwingWorkerstate bound property.- Returns:
- the current state
 
 
-