未来结果一到就更新UI

Question

我已使用DefaultListModel更新UI中列表中的字符串，该字符串由类返回，如图所示

class ResponseGiver implements Callable<Future>{

        int i;

       //Constructor to initialize i

     String call(){
      ...............
      ...............
      return i;
  }

我还有其他类会更新上面得到的结果

class Viewer {

    ExecutorService es = new Executors.newFixedThreadPool(10);
    List<Future<String>> futures = new ArrayList<Future<String>>();
    for(int i =0;i<10;i++)
      {
         futures.add(new ResponseGiver(i));
      }
 for(Future<String> x : futures)  //loop 2nd will be called 10 times
  {
     String p = x.get(); 
       //update GUI with p
   }

现在的问题是，假设在第2循环中，在第5循环中，get（）函数需要一些时间，比如10秒，在此期间，从第6到第10的其他期货都准备好了结果。所以我的屏幕会等待第5个结果，甚至第6到第10个都准备好了。我希望我的屏幕在10个期货中的任何一个返回结果后立即更新。

Answer 1

只需使用番石榴中的ListenableFuture。它要方便得多。

Answer 2

通过使用标准API，您可以使用ExecutorCompletionService。它允许提交可调用的实例并返回未来的对象，就像普通的ExecutorService一样。但它还允许按照对象完成的顺序获取未来的对象：使用ExecutorCompletionService#take（）方法。此方法会一直阻止，直到新的未来可用为止。您可以将此想象为期货被放入阻塞队列中。

您可以从完成服务启动一个使用这些未来对象的线程。这样的未来结果可用于更新GUI。（请注意，反过来，必须使用SwingUtilities.invokeLater在事件调度线程上再次执行此更新）。

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.SwingUtilities;

public class ExecutorCompletionServiceTest
{
    public static void main(String[] args)
    {
        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                createAndShowGUI();
            }
        });
    }

    private static void createAndShowGUI()
    {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        f.getContentPane().setLayout(new BorderLayout());

        JButton button = new JButton("Run");
        f.getContentPane().add(button, BorderLayout.NORTH);

        final DefaultListModel<String> listModel = new DefaultListModel<String>();
        JList<String> list = new JList<String>(listModel);
        f.getContentPane().add(new JScrollPane(list), BorderLayout.CENTER);

        final Callback callback = new Callback()
        {
            @Override
            public void call(final String result)
            {
                SwingUtilities.invokeLater(new Runnable()
                {
                    @Override
                    public void run()
                    {
                        listModel.addElement(result);
                    }
                });
            }
        };

        button.addActionListener(new ActionListener()
        {
            @Override
            public void actionPerformed(ActionEvent e)
            {
                createTasks(callback);
            }
        });

        f.setSize(300, 300);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }

    interface Callback
    {
        void call(String result);
    }


    private static Random random = new Random(0);

    static class ResponseGiver implements Callable<String>
    {
        private int i;

        ResponseGiver(int i)
        {
            this.i = i;
        }

        @Override
        public String call()
        {
            int delayMS = 250 + random.nextInt(500);

            // Simulate a longer delay for task 5
            if (i == 5)
            {
                delayMS += 3000;
            }
            try
            {
                System.out.println("For "+i+" waiting "+delayMS+" ms");
                Thread.sleep(delayMS);
                System.out.println("For "+i+" waiting "+delayMS+" ms DONE");
            }
            catch (InterruptedException e)
            {
                Thread.currentThread().interrupt();
            }
            return String.valueOf(i);
        }
    }

    private static void createTasks(final Callback callback)
    {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        final CompletionService<String> executorCompletionService =
            new ExecutorCompletionService<String>(executorService);
        final int n = 10;
        for (int i = 0; i < 10; i++)
        {
            executorCompletionService.submit(new ResponseGiver(i));
        }
        Thread thread = new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                processResults(executorCompletionService, n, callback);
            }
        });
        thread.start();
    }

    private static void processResults(
        CompletionService<String> completionService, int n, Callback callback)
    {
        for (int i = 0; i < n; i++)
        {
            try
            {
                Future<String> future = completionService.take();
                String result = future.get();
                if (result != null)
                {
                    callback.call(result);
                }
                System.out.println("Processed "+(i+1)+" of "+n+" results");
            }
            catch (InterruptedException e)
            {
                Thread.currentThread().interrupt();
            }
            catch (ExecutionException e)
            {
                e.printStackTrace();
            }
        }
    }
}