如何協調多個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中文網其他相關文章！