如何协调多个SwingWorker并发完成？

等待多个 SwingWorker

SwingWorker 是执行后台任务并从工作线程更新 GUI 的便捷方法。但是，可能存在多个 SwingWorker 实例同时运行的情况，因此有必要协调它们的完成。

考虑以下代码，其中在循环中创建和执行多个 SwingWorker：

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 < 10; i++) {
                    new SwingWorker<Void, Void>() {
                        @Override
                        protected Void doInBackground() throws Exception {
                            // Do some work
                            return null;
                        }
                    }.execute();
                }
            }
        });
        getContentPane().add(startButton);
    }
}

单击“Do work”按钮时，将创建并执行 10 个 SwingWorker 实例。每个 SwingWorker 在后台执行一些工作，并在工作完成后更新 GUI。然而，SwingWorkers 之间没有协调，这意味着它们可以按任何顺序完成，并可能导致 GUI 更新不稳定，特别是当底层任务花费不同的时间时。

确保 GUI 更新以一致且可预测的方式，协调 SwingWorkers 的完成非常重要。可以使用多种方法来实现此目的，最合适的方法取决于应用程序的具体要求。

1. Barrier

屏障是一种同步机制，允许多个线程等待，直到所有线程都到达公共点。在 SwingWorkers 的上下文中，可以使用屏障来确保 GUI 仅在所有 SwingWorkers 完成其任务后才更新，方法如下：

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 < NUM_WORKERS; i++) {
                    EXECUTOR.submit(new SwingWorker<Void, Void>() {

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

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

通过这种方法，SwingWorkers 可以同时执行其任务，并且Java 虚拟机 (JVM) 管理线程池并调度任务执行。当所有 SwingWorkers 完成任务时，屏障被触发，并执行屏障的 run() 方法，该方法负责更新 GUI。

2. CountDownLatch

CountDownLatch 是另一种同步机制，允许多个线程等待，直到发生一定数量的事件。在 SwingWorkers 的上下文中，CountDownLatch 可用于确保仅在所有 SwingWorkers 完成其任务后才更新 GUI，如下所示：

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 < NUM_WORKERS; i++) {
                    EXECUTOR.submit(new SwingWorker<Void, Void>() {

                        @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) {
        }
    }
}

通过这种方法，SwingWorkers 执行其任务同时，JVM 管理线程池并调度任务执行。当所有 SwingWorkers 完成其任务时，锁存器计数达到零，这允许小程序的 run() 方法继续执行并更新 GUI。

3. Phaser

Phaser 是同步

以上是如何协调多个SwingWorker并发完成？的详细内容。更多信息请关注PHP中文网其他相关文章！