SwingWorker Example using "progress" Property

Java Swing Tutorials - Herong's Tutorial Examples

∟SwingWorker - The Background Task Worker

∟SwingWorker Example using "progress" Property

This section provides a tutorial example on how to use java.swing.SwingWorker class with the setProgress() method to update the 'progress' property value from the doInBackground() method. A PropertyChangeListener class must be implemented to catch the updated value of the 'progress' property in the dispatch thread.

Example 3: Update "progress" property and use it to show progress - This example shows you how to communicate the "progress" of a background task to a Dispatch thread. Only 1 method and 1 listener class need to be implemented:

T doInBackground() - Instance method to be implemented to perform the task. Inside doInBackground(), the setProgress(int) method is called multiple times to publish an integer to indicate the progress of the background task as a percentage number.
class ... implements PropertyChangeListener {} - Listener class that implements the propertyChange() method to catch the updated percentage value.

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

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

// Extending the SwingWorker class
   protected Object doInBackground() {
      logMessage("doInBackground() started");
      int i = 0;
      Random r = new Random();
      try {
         while (i<total) {
            Thread.sleep(wait);
            Integer n = new Integer(r.nextInt());
            setProgress((100*(i+1))/total);
            i++;
         }
      } catch (Exception e) {
      	 e.printStackTrace();
      }
      logMessage("doInBackground() ended");
      return null;
   }
   
// Launching my extended SwingWorker class
   public static void main(String[] a) {
      try {
         SwingWorker worker = new SwingWorkerUsingProgress();
         dumpThreads();
         worker.addPropertyChangeListener(new myListener());
         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);
   }
   static class myListener implements PropertyChangeListener {
      public void propertyChange(PropertyChangeEvent e) {
         if ("progress".equals(e.getPropertyName())) {
            logMessage("propertyChange() "+e.getNewValue()+"%");
         }
      }
   }
}

Notes on the sample program:

When extending SwingWorker<T,V>, I am setting T to be Object because I am not returning any result; and setting V to be Object because I am not publish any intermediate values.
Object doInBackground() is implemented to generate some random numbers. Whenever a random number is generated, I call the setProgress() method to update the property called "progress" with an integer between 0 and 100 to indicate the percentage of the task progress.
class myListener {} is implemented with the java.beans.PropertyChangeListener interface to be attached to my SwingWorker instance to listen to value change events on the "progress" property.
void propertyChange() is implemented inside myListener{} to catch the updated "progress" property value.

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

C:\>java SwingWorkerUsingProgress

23:02:46.481 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]

23:02:46.521 Thread dump:
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    Thread[SwingWorker-pool-1-thread-1,5,main]
23:02:46.531 SwingWorker-pool-1-thread-1: doInBackground() started
23:02:46.571 AWT-EventQueue-0: propertyChange() 4%
23:02:46.621 AWT-EventQueue-0: propertyChange() 9%
23:02:46.671 AWT-EventQueue-0: propertyChange() 14%

23:02:46.721 Thread dump:
23:02:46.721 AWT-EventQueue-0: propertyChange() 19%
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]
23:02:46.771 AWT-EventQueue-0: propertyChange() 24%
23:02:46.821 AWT-EventQueue-0: propertyChange() 29%
23:02:46.871 AWT-EventQueue-0: propertyChange() 34%
23:02:46.921 AWT-EventQueue-0: propertyChange() 39%

23:02:46.921 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]
23:02:46.971 AWT-EventQueue-0: propertyChange() 44%
23:02:47.021 AWT-EventQueue-0: propertyChange() 49%
23:02:47.071 AWT-EventQueue-0: propertyChange() 54%
23:02:47.121 AWT-EventQueue-0: propertyChange() 59%

23:02:47.121 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]
23:02:47.171 AWT-EventQueue-0: propertyChange() 64%
23:02:47.221 AWT-EventQueue-0: propertyChange() 69%
23:02:47.271 AWT-EventQueue-0: propertyChange() 74%
23:02:47.321 AWT-EventQueue-0: propertyChange() 79%

23:02:47.331 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]
23:02:47.371 AWT-EventQueue-0: propertyChange() 84%
23:02:47.421 AWT-EventQueue-0: propertyChange() 89%
23:02:47.471 AWT-EventQueue-0: propertyChange() 94%
23:02:47.521 AWT-EventQueue-0: propertyChange() 99%
23:02:47.531 SwingWorker-pool-1-thread-1: doInBackground() ended

23:02:47.531 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]
23:02:47.571 AWT-EventQueue-0: propertyChange() 100%

23:02:47.731 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]

23:02:47.931 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]

Some interesting notes on the output:

The log message in the output: "23:02:46.571 AWT-EventQueue-0: propertyChange() 4%" shows that the propertyChange() method was called in the "AWT-EventQueue-0" thread. So "AWT-EventQueue-0" is a Dispatch thread in our example.
The log message in the output: "23:02:46.571 AWT-EventQueue-0: propertyChange() 4%" also shows that the process() method is called only once after 4 calls of setProgress(), because I don't see 1%, 2% and 3% "progress" property values showing in output.

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 repeatedly updating "progress" property value inside the doInBackground() method, and using a PropertyChangeListener class to catch it:
SwingWorker Threads using Progress Property