Java-SwingWorker-问题

Question

我正在开发一个 Java 桌面应用程序。此应用程序执行相同的任务 public class MyTask Implements Callable{ 同时在多个线程中。

现在，当用户单击“开始”按钮时，我创建了一个 SwingWorker myWorker 并执行了它。

现在，此 myWorker 创建 MyTask 的多个实例，并将它们提交给 ExecutorService。

每个 MyTask 实例都有一个循环，并在每次迭代时生成中间结果。现在，我想在生成每个 MyTask 实例后立即收集这些中间结果。然后，从每个 MyTask 实例收集这些中间结果后，我想通过 SwingWorker.publish(MyObject) 发布它，以便在 EDT 上显示进度。

Q1.我该如何实现这个？我是否应该创建 SwingWorker 的 MyTask 子类而不是 Callable 来获得中间结果，因为我认为 Callable 仅返回最终结果。

Q2。如果回答Q1。是的，那么您能给我一个小例子来展示如何获取这些中间结果并聚合它们，然后从主 SwingWorker 发布它们吗？

Q3.如果在这种情况下我无法使用SwingWorker，那么我该如何实现呢？

Answer 1

看一下 ExecutorCompletionService。它是一个 Executor，提供 take 方法来检索任何已完成任务的结果。

更新：

扩展 SwingWorker 不会执行您想要的操作，因为它专门用于将工作从 EDT 卸载到后台线程。您不能使用它将工作从后台线程卸载到其他后台线程。调用 SwingWorker.publish 会产生相当于 SwingUtilities.invokeLater 的结果。据我所知，没有任何机制可以从后台线程到后台线程执行相同的操作。最好的选择是使用对 Queue 的引用来创建 MyTask ，并让 SwingWorker.doInBackground 轮询队列以获取中间结果。

Answer 2

A1+A2。
Yatendra，您的 Main SwingWorker 是否必须是唯一将临时结果传递给 EDT 的？如果您的任务也是 SwingWorker 实例，则 Main Worker 可以将将临时结果发送回 EDT 的责任委托给它们，而只需处理 TaskWorkers< /code> 生命周期。

package threading;

import java.util.LinkedList;
import java.util.List;

import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;

class MainSwingWorker extends SwingWorker<Void, Void> {
    private List<TaskWorker> tasks;

    public MainSwingWorker() {
        tasks = new LinkedList<TaskWorker>();
        for(int i=0; i<2; i++) 
            tasks.add(new TaskWorker(i));
    }

    @Override
    public Void doInBackground() throws Exception {
        Test.log("Building tasks.");                    
        for(TaskWorker task : tasks) 
            launch(task);
        Test.log("Waiting 5 secs.");
        Thread.sleep(5000);

        Test.log("Cancelling tasks");

        for(TaskWorker task : tasks ) 
            task.cancel(true);

        return null;
    }

    private void launch(final TaskWorker task) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                Test.log("Launching task worker.");
                task.execute();
            }
        });     
    }
}

class TaskWorker extends SwingWorker<Void, String> {
    private int id;

    public TaskWorker(int wid) {
        id = wid;
    }

    @Override
    public Void doInBackground() throws Exception {     
        System.out.format("[%s] Starting worker %s\n", Thread.currentThread().getName(), id );
        while( !isCancelled() ) {
            // ***************************
            // your task process code here
            // ***************************
            publish(String.format("A dummy interim result #%s", id));
            Thread.sleep(1000);
        }       
        return null;
    }

    @Override
    public void process(List<String> results) {
        // it's pretty obvious, that once this method gets called you can safely 
        // call the Swing API from EDT among with the interim results
        for(String result : results )
            Test.log(result);
    }
}

public class Test {

    public static void log(String msg) {
        System.out.format("[%s] %s\n", Thread.currentThread().getName(), msg);
    }

    public static void main(String[] args) throws Exception {
        log("Init.");
        SwingUtilities.invokeAndWait(new Runnable() {
            @Override
            public void run() {
                log("Starting main worker.");
                MainSwingWorker worker = new MainSwingWorker();
                worker.execute();                           
            }
        });
        Thread.sleep(7000);
        log("Finished.");
    }
}

请记住，这只是一个测试，我知道有一些丑陋的 Thread.sleep(long) 调用。

[main] Init.
[AWT-EventQueue-0] Starting main worker.
[SwingWorker-pool-1-thread-1] Building tasks.
[SwingWorker-pool-1-thread-1] Waiting 5 secs.
[AWT-EventQueue-0] Launching task worker.
[AWT-EventQueue-0] Launching task worker.
[SwingWorker-pool-1-thread-2] Starting worker 0
[SwingWorker-pool-1-thread-3] Starting worker 1
[AWT-EventQueue-0] A dummy interim result #1
[AWT-EventQueue-0] A dummy interim result #0
[AWT-EventQueue-0] A dummy interim result #0
[AWT-EventQueue-0] A dummy interim result #1
[AWT-EventQueue-0] A dummy interim result #1
[AWT-EventQueue-0] A dummy interim result #0
[AWT-EventQueue-0] A dummy interim result #0
[AWT-EventQueue-0] A dummy interim result #1
[AWT-EventQueue-0] A dummy interim result #0
[AWT-EventQueue-0] A dummy interim result #1
[SwingWorker-pool-1-thread-1] Cancelling tasks
[main] Finished.

A3
但是，如果您的项目需要另一个 ExecutorService 来安排任务执行，那么我将实现类似的发布进程机制来执行主 Swing 工作线程和该任务线程之间的通信。虽然看起来很重复，但您可以使用 java.concurrent.ConcurrentQueue 来存储可用的临时结果吗？

PS：我几天前才注意到，但是 SwingWorkers 周围有一个恼人的错误，阻止其 ExecutorService 缓存未使用的线程。

Answer 3

SwingWorker 也是未来。因此，它具有 get() 方法，可以在 did() 方法内部使用该方法，以在该方法完成时获取 doInBackground() 的结果。

因此，结构变得有点像：

SwingWorker<T,P> sw=new SwingWorker<T,P>() {

  @Override
  public T doInBackground() throws Exception {
    T result;
    // do stuff here
    return result;
  }

  @Override
  public void done() {
    try {
      T result=get();
      // do stuff with result.
    }
    catch(ExecutionException e) {
      Exception fromDoInBackground= (Exception) e.getCause();
      // handle exception thrown from doInBackground()
    }
    catch(InterruptedException i) {
      // handle the case in which a SwingWorker was cancelled. typically: do nothing.
    }
  }
};