How to Coordinate the Completion of Multiple Concurrent SwingWorkers?

Waiting for multiple SwingWorkers

SwingWorker is a convenient way to perform background tasks and update the GUI from the worker thread. However, there may be situations where multiple SwingWorker instances are running concurrently, and it becomes necessary to coordinate their completion.

Consider the following code, where multiple SwingWorkers are created and executed in a loop:

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.InvocationTargetException;
import javax.swing.*;

public class TestApplet extends JApplet {

    @Override
    public void init() {
        try {
            SwingUtilities.invokeAndWait(new Runnable() {
                @Override
                public void run() {
                    createGUI();
                }
            });
        } catch (InterruptedException | InvocationTargetException ex) {
        }
    }

    private void createGUI() {
        getContentPane().setLayout(new FlowLayout());
        JButton startButton = new JButton("Do work");
        startButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                for (int i = 0; i () {
                        @Override
                        protected Void doInBackground() throws Exception {
                            // Do some work
                            return null;
                        }
                    }.execute();
                }
            }
        });
        getContentPane().add(startButton);
    }
}

When the "Do work" button is clicked, 10 SwingWorker instances are created and executed. Each SwingWorker performs some work in the background and updates the GUI when the work is done. However, there is no coordination between the SwingWorkers, which means they can complete in any order and may cause the GUI to update erratically, especially if the underlying tasks take varying amounts of time.

To ensure that the GUI updates in a consistent and predictable manner, it is important to coordinate the completion of the SwingWorkers. Several approaches can be used to achieve this, and the most suitable approach depends on the specific requirements of the application.

1. Barrier

A barrier is a synchronization mechanism that allows multiple threads to wait until all of them have reached a common point. In the context of SwingWorkers, a barrier can be used to ensure that the GUI updates only after all SwingWorkers have completed their tasks by doing this:

import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.*;
import javax.swing.*;

public class TestApplet extends JApplet {

    private static final int NUM_WORKERS = 10;
    private static final ExecutorService EXECUTOR = Executors.newFixedThreadPool(NUM_WORKERS);
    private static final CyclicBarrier BARRIER = new CyclicBarrier(NUM_WORKERS, new Runnable() {

        @Override
        public void run() {
            // All SwingWorkers have completed, update the GUI
        }
    });

    @Override
    public void init() {
        try {
            SwingUtilities.invokeAndWait(new Runnable() {
                @Override
                public void run() {
                    createGUI();
                }
            });
        } catch (InterruptedException | InvocationTargetException ex) {
        }
    }

    private void createGUI() {
        JButton startButton = new JButton("Do work");
        startButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                for (int i = 0; i () {

                        @Override
                        protected Void doInBackground() throws Exception {
                            // Do some work
                            return null;
                        }

                        @Override
                        protected void done() {
                            BARRIER.await();
                        }
                    });
                }
            }
        });
        getContentPane().add(startButton);
    }
}

With this approach, the SwingWorkers execute their tasks concurrently, and the Java Virtual Machine (JVM) manages the thread pool and schedules the tasks for execution. When all SwingWorkers have completed their tasks, the barrier is triggered, and the run() method of the barrier is executed, which is responsible for updating the GUI.

2. CountDownLatch

A CountDownLatch is another synchronization mechanism that allows multiple threads to wait until a certain number of events have occurred. In the context of SwingWorkers, a CountDownLatch can be used to ensure that the GUI updates only after all SwingWorkers have completed their tasks as it is done like this:

import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.*;
import javax.swing.*;

public class TestApplet extends JApplet {

    private static final int NUM_WORKERS = 10;
    private static final ExecutorService EXECUTOR = Executors.newFixedThreadPool(NUM_WORKERS);
    private static final CountDownLatch LATCH = new CountDownLatch(NUM_WORKERS);

    @Override
    public void init() {
        try {
            SwingUtilities.invokeAndWait(new Runnable() {
                @Override
                public void run() {
                    createGUI();
                }
            });
        } catch (InterruptedException | InvocationTargetException ex) {
        }
    }

    private void createGUI() {
        JButton startButton = new JButton("Do work");
        startButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                for (int i = 0; i () {

                        @Override
                        protected Void doInBackground() throws Exception {
                            // Do some work
                            return null;
                        }

                        @Override
                        protected void done() {
                            LATCH.countDown();
                        }
                    });
                }
            }
        });
        getContentPane().add(startButton);
    }

    private void updateGUI() {
        // Update the GUI
    }

    @Override
    public void run() {
        try {
            LATCH.await();
            updateGUI();
        } catch (InterruptedException ex) {
        }
    }
}

With this approach, the SwingWorkers execute their tasks concurrently, and the JVM manages the thread pool and schedules the tasks for execution. When all SwingWorkers have completed their tasks, the latch count reaches zero, which allows the run() method of the applet to continue execution and update the GUI.

3. Phaser

A Phaser is a synchronization

The above is the detailed content of How to Coordinate the Completion of Multiple Concurrent SwingWorkers?. For more information, please follow other related articles on the PHP Chinese website!