SwingWorker Example using done() Method

Java Swing Tutorials - Herong's Tutorial Examples

∟SwingWorker - The Background Task Worker

∟SwingWorker Example using done() Method

This section provides a tutorial example on how to use java.swing.SwingWorker class with the done() method to communicate the calculation result out into a dispatch thread.

There are several ways to use the SwingWorker class. Let's start with the simplest one first.

Example 1: Get notified when task is done and retrieve the result - This example shows the simplest way of using the SwingWorker class to just launch the Worker thread and catch the result in the Dispatch thread. Only 2 methods need to be implemented:

T doInBackground() - Instance method to be implemented to perform the task. The doInBackground() method will be executed in the Worker thread.
void done() - Instance method to be implemented, if you want to do something when the task is done. The done() method will be executed in the Dispatch thread.

Here is the source code of the example program, SwingWorkerUsingDone.java:

/* SwingWorkerUsingDone.java
 * Copyright (c) 2014, HerongYang.com, All Rights Reserved.
 */
import javax.swing.SwingWorker;
import java.util.List;
import java.util.Random;
import java.time.LocalTime;
public class SwingWorkerUsingDone 
   extends SwingWorker<Integer[], Object> {
   int total = 100;
   int wait = 10;

// Extending the SwingWorker class
   protected Integer[] doInBackground() {
      logMessage("doInBackground() started");
      int i = 0;
      Integer[] l = new Integer[total];
      Random r = new Random();
      try {
         while (i<total) {
            Thread.sleep(wait);
            Integer n = new Integer(r.nextInt());
            l[i] = n;
            i++;
         }
      } catch (Exception e) {
      	 e.printStackTrace();
      }
      logMessage("doInBackground() ended");
      return l;
   }
   
   protected void done() {
      logMessage("done() started");
      try {
        Integer[] r = get();
        System.out.println("# of element in the result: "+r.length);
        System.out.println("First element: "+r[0]);
        System.out.println("Last element: "+r[total-1]);
      } catch (Exception e) {
      	 e.printStackTrace();
      }
      logMessage("done() ended");
   }
   
// Launching my extended SwingWorker class
   public static void main(String[] a) {
      try {
         SwingWorker worker = new SwingWorkerUsingDone();
         dumpThreads();
         worker.execute();
         while (true) {
            dumpThreads();
            Thread.sleep(200);
         }
      } catch (Exception e) {
      	 e.printStackTrace();
      }
   }
   public static void dumpThreads() {
      System.out.println(LocalTime.now()+" Thread dump:");
      Thread.currentThread().getThreadGroup().list();
   }
   public static void logMessage(String s) {
      System.out.println(LocalTime.now()+" "
         +Thread.currentThread().getName()+": "+s);
   }
}

Notes on the sample program:

My class, SwingWorkerUsingDone, in this example is playing double roles acting both as an extended class of java.swing.SwingWorker and as the main class to start the application.
Note that SwingWorker class is a generic class that takes two type parameters <T,V>, where T is the data type of the result returned by the doInBackground() method; and V is the data type of intermediate values to be published by the doInBackground() method. In this example, I am setting T to be Integer[] to return result in an array of Integer; and setting V to be Object to publish intermediate values, which is not used anyway.
Integer[] doInBackground() is implemented to generate some random numbers. An Integer array is created to store all random numbers generated and returned at the end of the method. Note that "Thread.sleep()" is used to make execution last longer.
void done() is implemented to retrieve the Integer array returned by doInBackground().
void main() method is implemented so that SwingWorkerUsingDone can be used as the main class to start the application. In this example, I am just creating a new instance of SwingWorkerUsingDone and calling its execute() method. Then a simple loop is used to watch how many threads are running in the application.

If you compile and run this example with JDK 1.8, you should get output messages similar to these:

C:\>java SwingWorkerUsingDone

21:59:22.601 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]

21:59:22.683 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    Thread[SwingWorker-pool-1-thread-1,5,main]
21:59:22.695 SwingWorker-pool-1-thread-1: doInBackground() started

21:59:22.884 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    Thread[SwingWorker-pool-1-thread-1,5,main]
    Thread[AWT-Shutdown,5,main]
    Thread[AWT-Windows,6,main]
    Thread[AWT-EventQueue-0,6,main]

21:59:23.091 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    Thread[SwingWorker-pool-1-thread-1,5,main]
    Thread[AWT-Shutdown,5,main]
    Thread[AWT-Windows,6,main]
    Thread[AWT-EventQueue-0,6,main]

21:59:23.299 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    Thread[SwingWorker-pool-1-thread-1,5,main]
    Thread[AWT-Shutdown,5,main]
    Thread[AWT-Windows,6,main]
    Thread[AWT-EventQueue-0,6,main]

21:59:23.507 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    Thread[SwingWorker-pool-1-thread-1,5,main]
    Thread[AWT-Shutdown,5,main]
    Thread[AWT-Windows,6,main]
    Thread[AWT-EventQueue-0,6,main]
21:59:23.695 SwingWorker-pool-1-thread-1: doInBackground() ended

21:59:23.714 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    Thread[SwingWorker-pool-1-thread-1,5,main]
    Thread[AWT-Shutdown,5,main]
    Thread[AWT-Windows,6,main]
    Thread[AWT-EventQueue-0,6,main]
21:59:23.730 AWT-EventQueue-0: done() started
# of element in the result: 100
First element: 1278389322
Last element: 1363500147
21:59:23.731 AWT-EventQueue-0: done() ended

21:59:23.918 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    Thread[SwingWorker-pool-1-thread-1,5,main]
    Thread[AWT-Windows,6,main]
    Thread[AWT-EventQueue-0,6,main]

21:59:24.123 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    Thread[SwingWorker-pool-1-thread-1,5,main]
    Thread[AWT-Windows,6,main]
    Thread[AWT-EventQueue-0,6,main]
...

Some interesting notes on the output:

The first thread dump at 21:59:22.601 shows that there was only 1 application thread running: "main", after the application started.
The second thread dump at 21:59:22.683 shows that there were 2 application thread running: "main" and "SwingWorker-pool-1-thread-1", right after worker.execute() was called.
The log message in the output: "21:59:22.695 SwingWorker-pool-1-thread-1: doInBackground() started" confirms that "SwingWorker-pool-1-thread-1" is the Worker thread created by the worker.execute() call to run the background task.
The third thread dump at 21:59:22.884 shows that there were 5 application thread running: "main", "SwingWorker-pool-1-thread-1", "AWT-Shutdown", "AWT-Windows", and "AWT-EventQueue-0". So "SwingWorker-pool-1-thread-1" created 3 more threads.
The log message in the output: "21:59:23.695 SwingWorker-pool-1-thread-1: doInBackground() ended" shows when doInBackground() was ended.
The log message in the output: "21:59:23.730 AWT-EventQueue-0: done() started" shows that the done() method was called in the "AWT-EventQueue-0" thread. So "AWT-EventQueue-0" is a Dispatch thread in our example.
"# of element in the result: 100" message in the output confirms the get() returned all 100 random numbers generated by the doInBackground method in the Worker thread.
The thread dump at 21:59:23.918 shows that the Worker thread "SwingWorker-pool-1-thread-1" continued to live even after the background task was fully completed. May be JDK is using thread pool to share meet all Worker thread requests as the thread name suggests?
The Dispatch thread "AWT-EventQueue" also stayed live. I not sure why.

The picture below gives you an idea on how the Launching thread, the Worker thread, and the Dispatch thread worked together in this example where I am only interested to interact with the done() method at the end of the background task:
SwingWorker Threads using done() Method