En attente de plusieurs SwingWorkers

SwingWorker est un moyen pratique d'effectuer des taches 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 taches 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 taches 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 taches simultanément, et la machine virtuelle Java (JVM) gère le pool de threads et planifie l'exécution des taches. Lorsque tous les SwingWorkers ont terminé leurs taches, 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 taches, 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 taches. simultanément, et la JVM gère le pool de threads et planifie les taches à exécuter. Lorsque tous les SwingWorkers ont terminé leurs taches, 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!