Comment coordonner la réalisation de plusieurs SwingWorkers simultanés ?

En attente de plusieurs SwingWorkers

SwingWorker est un moyen pratique d'effectuer des tâches en arrière-plan et de mettre à jour l'interface graphique à partir du thread de travail. Cependant, il peut y avoir des situations où plusieurs instances SwingWorker s'exécutent simultanément et il devient nécessaire de coordonner leur achèvement.

Considérez le code suivant, dans lequel plusieurs SwingWorkers sont créés et exécutés en boucle :

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

Lorsque vous cliquez sur le bouton "Faire du travail", 10 instances SwingWorker sont créées et exécutées. Chaque SwingWorker effectue un travail en arrière-plan et met à jour l'interface graphique lorsque le travail est terminé. Cependant, il n'y a aucune coordination entre les SwingWorkers, ce qui signifie qu'ils peuvent effectuer n'importe quel ordre et peuvent entraîner une mise à jour erratique de l'interface graphique, surtout si les tâches sous-jacentes prennent plus ou moins de temps.

Pour garantir que les mises à jour de l'interface graphique de manière cohérente et prévisible, il est important de coordonner la réalisation des SwingWorkers. Plusieurs approches peuvent être utilisées pour y parvenir, et l'approche la plus adaptée dépend des exigences spécifiques de l'application.

1. Barrière

Une barrière est un mécanisme de synchronisation qui permet à plusieurs threads d'attendre jusqu'à ce qu'ils aient tous atteint un point commun. Dans le contexte de SwingWorkers, une barrière peut être utilisée pour garantir que l'interface graphique se met à jour uniquement une fois que tous les SwingWorkers ont terminé leurs tâches en procédant ainsi :

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

Avec cette approche, les SwingWorkers exécutent leurs tâches simultanément, et la machine virtuelle Java (JVM) gère le pool de threads et planifie l'exécution des tâches. Lorsque tous les SwingWorkers ont terminé leurs tâches, la barrière est déclenchée et la méthode run() de la barrière est exécutée, qui est responsable de la mise à jour de l'interface graphique.

2. CountDownLatch

Un CountDownLatch est un autre mécanisme de synchronisation qui permet à plusieurs threads d'attendre qu'un certain nombre d'événements se produisent. Dans le contexte de SwingWorkers, un CountDownLatch peut être utilisé pour garantir que l'interface graphique se met à jour uniquement une fois que tous les SwingWorkers ont terminé leurs tâches, comme ceci :

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

Avec cette approche, les SwingWorkers exécutent leurs tâches. simultanément, et la JVM gère le pool de threads et planifie les tâches à exécuter. Lorsque tous les SwingWorkers ont terminé leurs tâches, le nombre de verrous atteint zéro, ce qui permet à la méthode run() de l'applet de continuer l'exécution et de mettre à jour l'interface graphique.

3. Phaser

Un Phaser est une synchronisation

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!