Wie koordiniere ich den Abschluss mehrerer gleichzeitiger SwingWorker?

Warten auf mehrere SwingWorker

SwingWorker ist eine praktische Möglichkeit, Hintergrundaufgaben auszuführen und die GUI vom Worker-Thread aus zu aktualisieren. Es kann jedoch Situationen geben, in denen mehrere SwingWorker-Instanzen gleichzeitig ausgeführt werden und es notwendig wird, deren Abschluss zu koordinieren.

Betrachten Sie den folgenden Code, in dem mehrere SwingWorker erstellt und in einer Schleife ausgeführt werden:

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);
    }
}

Wenn auf die Schaltfläche „Arbeit ausführen“ geklickt wird, werden 10 SwingWorker-Instanzen erstellt und ausgeführt. Jeder SwingWorker führt einige Arbeiten im Hintergrund aus und aktualisiert die GUI, wenn die Arbeit erledigt ist. Es gibt jedoch keine Koordination zwischen den SwingWorkern, was bedeutet, dass sie in beliebiger Reihenfolge abschließen können und dazu führen können, dass die GUI unregelmäßig aktualisiert wird, insbesondere wenn die zugrunde liegenden Aufgaben unterschiedlich viel Zeit in Anspruch nehmen.

Um sicherzustellen, dass die GUI aktualisiert wird Es ist wichtig, die Fertigstellung der SwingWorkers konsistent und vorhersehbar zu koordinieren. Um dies zu erreichen, können mehrere Ansätze verwendet werden, und der am besten geeignete Ansatz hängt von den spezifischen Anforderungen der Anwendung ab.

1. Barriere

Eine Barriere ist ein Synchronisationsmechanismus, der es mehreren Threads ermöglicht, zu warten, bis alle einen gemeinsamen Punkt erreicht haben. Im Kontext von SwingWorkern kann eine Barriere verwendet werden, um sicherzustellen, dass die GUI erst aktualisiert wird, nachdem alle SwingWorker ihre Aufgaben abgeschlossen haben, indem Sie Folgendes tun:

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);
    }
}

Bei diesem Ansatz führen die SwingWorker ihre Aufgaben gleichzeitig aus und Die Java Virtual Machine (JVM) verwaltet den Thread-Pool und plant die Ausführung der Aufgaben. Wenn alle SwingWorker ihre Aufgaben erledigt haben, wird die Barriere ausgelöst und die run()-Methode der Barriere ausgeführt, die für die Aktualisierung der GUI verantwortlich ist.

2. CountDownLatch

Ein CountDownLatch ist ein weiterer Synchronisationsmechanismus, der es mehreren Threads ermöglicht, zu warten, bis eine bestimmte Anzahl von Ereignissen aufgetreten ist. Im Kontext von SwingWorkers kann ein CountDownLatch verwendet werden, um sicherzustellen, dass die GUI erst aktualisiert wird, nachdem alle SwingWorker ihre Aufgaben abgeschlossen haben, wie folgt:

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

Mit diesem Ansatz führen die SwingWorker ihre Aufgaben aus gleichzeitig, und die JVM verwaltet den Thread-Pool und plant die Ausführung der Aufgaben. Wenn alle SwingWorker ihre Aufgaben abgeschlossen haben, erreicht die Latch-Zählung Null, wodurch die run()-Methode des Applets die Ausführung fortsetzen und die GUI aktualisieren kann.

3. Phaser

Ein Phaser ist eine Synchronisation

Das obige ist der detaillierte Inhalt vonWie koordiniere ich den Abschluss mehrerer gleichzeitiger SwingWorker?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!