Menunggu berbilang SwingWorkers

SwingWorker ialah cara yang mudah untuk melaksanakan tugas latar belakang dan mengemas kini GUI daripada urutan pekerja. Walau bagaimanapun, mungkin terdapat situasi di mana berbilang tika SwingWorker berjalan serentak, dan ia menjadi perlu untuk menyelaraskan penyiapannya.

Pertimbangkan kod berikut, di mana berbilang SwingWorkers dicipta dan dilaksanakan dalam satu gelung:

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

Apabila butang "Lakukan kerja" diklik, 10 tika SwingWorker dibuat dan dilaksanakan. Setiap SwingWorker melakukan beberapa kerja di latar belakang dan mengemas kini GUI apabila kerja selesai. Walau bagaimanapun, tiada penyelarasan antara SwingWorkers, yang bermaksud mereka boleh melengkapkan dalam sebarang susunan dan boleh menyebabkan GUI dikemas kini secara tidak menentu, terutamanya jika tugas asas mengambil masa yang berbeza-beza.

Untuk memastikan GUI dikemas kini dengan cara yang konsisten dan boleh diramal, adalah penting untuk menyelaraskan penyiapan SwingWorkers. Beberapa pendekatan boleh digunakan untuk mencapai ini, dan pendekatan yang paling sesuai bergantung pada keperluan khusus aplikasi.

1. Penghalang

Penghalang ialah mekanisme penyegerakan yang membenarkan berbilang rangkaian menunggu sehingga kesemuanya mencapai titik yang sama. Dalam konteks SwingWorkers, halangan boleh digunakan untuk memastikan GUI dikemas kini hanya selepas semua SwingWorkers menyelesaikan tugas mereka dengan melakukan perkara ini:

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

Dengan pendekatan ini, SwingWorkers melaksanakan tugas mereka secara serentak, dan Mesin Maya Java (JVM) menguruskan kumpulan benang dan menjadualkan tugas untuk pelaksanaan. Apabila semua SwingWorkers telah menyelesaikan tugas mereka, halangan dicetuskan, dan kaedah run() halangan dilaksanakan, yang bertanggungjawab untuk mengemas kini GUI.

2. CountDownLatch

CountDownLatch ialah satu lagi mekanisme penyegerakan yang membenarkan berbilang urutan menunggu sehingga beberapa peristiwa telah berlaku. Dalam konteks SwingWorkers, CountDownLatch boleh digunakan untuk memastikan bahawa GUI dikemas kini hanya selepas semua SwingWorkers menyelesaikan tugas mereka kerana ia dilakukan seperti ini:

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

Dengan pendekatan ini, SwingWorkers melaksanakan tugas mereka serentak, dan JVM menguruskan kumpulan benang dan menjadualkan tugas untuk dilaksanakan. Apabila semua SwingWorkers telah menyelesaikan tugas mereka, kiraan selak mencapai sifar, yang membolehkan kaedah run() applet meneruskan pelaksanaan dan mengemas kini GUI.

3. Phaser

Phaser ialah penyegerakan

Atas ialah kandungan terperinci Bagaimana untuk Menyelaraskan Penyiapan Berbilang SwingWorkers Serentak?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!