CompletionService 简介

　　以下是jdk关于CompletionService的简介：

public interface CompletionService<V>

• 将生产新的异步任务与使用已完成任务的结果分离开来的服务。生产者submit 执行的任务。使用者take已完成的任务，并按照完成这些任务的顺序处理它们的结果。例如，CompletionService 可以用来管理异步 IO ，执行读操作的任务作为程序或系统的一部分提交，然后，当完成读操作时，会在程序的不同部分执行其他操作，执行操作的顺序可能与所请求的顺序不同。
• 通常，CompletionService 依赖于一个单独的 Executor 来实际执行任务，在这种情况下，CompletionService 只管理一个内部完成队列。ExecutorCompletionService 类提供了此方法的一个实现。
• 内存一致性效果：线程中向 CompletionService 提交任务之前的操作 happen-before 该任务执行的操作，后者依次 happen-before 紧跟在从对应 take() 成功返回的操作。
• CompletionService采取的是BlockingQueue<Future<V>>无界队列来管理Future。则有一个线程执行完毕把返回结果放到BlockingQueue<Future<V>>里面。就可以通过 completionServcie.take().get()取出结果。

方法区别：

• take 方获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。<如果需要用到返回值建议用take>
• poll 获取并移除表示下一个已完成任务的 Future，如果不存在这样的任务，则返回null。

public class ReportGenerator implements Callable<String> {
    private String sender;
    private String title;
    public ReportGenerator(String sender, String title) {
        this.sender = sender;
        this.title = title;
    }
    @Override
    public String call() throws Exception {
        try {
            long duration=(long) (Math.random()*10);
            System.out.println(sender+"_"+title+" ReportGenerator:Generating a report during "+duration+" seconds");
            TimeUnit.SECONDS.sleep(duration);
        } catch (Exception e) {
            e.printStackTrace();
        }
        String ret=sender+":"+title;
        return ret;
    }
}

public class ReportRequest implements Runnable {
    private String name;
    private CompletionService<String> service;
    public ReportRequest(String name, CompletionService<String> service) {
        super();
        this.name = name;
        this.service = service;
    }
    @Override
    public void run() {
        ReportGenerator generator=new ReportGenerator(name, "Reporter");
        service.submit(generator);
    }
}

public class ReportProcessor implements Runnable {
    private CompletionService<String> service;
    private boolean end;
    public ReportProcessor(CompletionService<String> service) {
        super();
        this.service = service;
        this.end = false;
    }
    @Override
    public void run() {
        while (!end) {
            try {
                Future<String> future = service.poll(20, TimeUnit.SECONDS);
                if (future != null) {
                    String report = future.get();
                    System.out.println("ReportReceiver: Report Received:"+ report);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("ReportSender: End");
    }
    public void setEnd(boolean end){
        this.end=end;
    }
}

public class CompletionMain {
    public static void main(String[] args) {
        ExecutorService service=Executors.newCachedThreadPool();
        CompletionService<String> service2=new ExecutorCompletionService<String>(service);

        ReportRequest faceRequest=new ReportRequest("face", service2);
        ReportRequest onlineRequest=new ReportRequest("online", service2);
        Thread faceThread=new Thread(faceRequest);
        Thread onlineThread=new Thread(onlineRequest);

        ReportProcessor processor=new ReportProcessor(service2);
        Thread senderThread=new Thread(processor);

        System.out.println("Main: Starting the Threads");
        faceThread.start();
        onlineThread.start();
        senderThread.start();

        try {
            System.out.println("Main: waiting for the report generator");
            faceThread.join();
            onlineThread.join();
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("Main:Shuting down the executor");
        service.shutdown();
        try {
            service.awaitTermination(1, TimeUnit.DAYS);
        } catch (Exception e) {
            e.printStackTrace();
        }
        processor.setEnd(true);
        System.out.println("Main：Ends");
    }
}

　   《Java并发编程实践》一书6.3.5节CompletionService：Executor和BlockingQueue，有这样一段话：

　　"如果向Executor提交了一组计算任务，并且希望在计算完成后获得结果，那么可以保留与每个任务关联的Future，然后反复使用get方法，同时将参数timeout指定为0，从而通过轮询来判断任务是否完成。这种方法虽然可行，但却有些繁琐。幸运的是，还有一种更好的方法：完成服务 CompletionService。"

　　这是什么意思呢？我们通过一个例子，分别使用繁琐的做法和CompletionService来完成，清晰的对比能让我们更好的理解上面的一段话和CompletionService这个API提供的初衷。考虑这样的场景，有5个Callable任务分别返回5个整数，然后我们在main方法中按照各个任务完成的先后顺序，在控制台打印返回结果。

public class ReturnAfterSleepCallable implements Callable<Integer>
{
  private int sleepSeconds;
  private int returnValue;
  public ReturnAfterSleepCallable(int sleepSeconds, int returnValue)
  {
    this.sleepSeconds = sleepSeconds;
    this.returnValue = returnValue;
  }
  @Override
  public Integer call() throws Exception
  {
    System.out.println("begin to execute.");
    TimeUnit.SECONDS.sleep(sleepSeconds);
    System.out.println("end to execute.");
    return returnValue;
  }
}

　　这个任务会接受2个参数，睡眠指定的时间后，返回指定的结果。睡眠时间越短，意味着任务越先执行完成。

1.繁琐的做法

　　通过一个List来保存每个任务返回的Future，然后轮询这些Future，直到每个Future都已完成。我们不希望出现因为排在前面的任务阻塞导致后面先完成的任务的结果没有及时获取的情况，所以在调用get方式时，需要将超时时间设置为0。

public class TraditionalTest{
  public static void main(String[] args)
  {
    int taskSize = 5;
    ExecutorService executor = Executors.newFixedThreadPool(taskSize);
    List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();
    for (int i = 1; i <= taskSize; i++){
      int sleep = taskSize - i; // 睡眠时间
      int value = i; // 返回结果
      // 向线程池提交任务
      Future<Integer> future = executor.submit(new ReturnAfterSleepCallable(sleep, value));
      // 保留每个任务的Future
      futureList.add(future);
    }
    // 轮询,获取完成任务的返回结果
    while(taskSize > 0){
      for (Future<Integer> future : futureList){
        Integer result = null;
        try{
          result = future.get(0, TimeUnit.SECONDS);
        } catch (InterruptedException e){
          e.printStackTrace();
        } catch (ExecutionException e){
          e.printStackTrace();
        } catch (TimeoutException e){
          // 超时异常需要忽略,因为我们设置了等待时间为0,只要任务没有完成,就会报该异常
        }
        // 任务已经完成
        if(result != null) {
          System.out.println("result=" + result);
          // 从future列表中删除已经完成的任务
          futureList.remove(future);
          taskSize--;
          //此处必须break，否则会抛出并发修改异常。（也可以通过将futureList声明为CopyOnWriteArrayList类型解决）
          break; // 进行下一次while循环
        }
      }
    }
    // 所有任务已经完成,关闭线程池
    System.out.println("all over.");
    executor.shutdown();
  }
}

　　可见轮询future列表非常的复杂，而且还有很多异常需要处理，TimeOutException异常需要忽略；还要通过双重循环和break，防止遍历集合的过程中，出现并发修改异常。这么多需要考虑的细节，程序员很容易犯错。

2.使用CompletionService

public class CompletionServiceTest{
  public static void main(String[] args) {
     int taskSize = 5;
     ExecutorService executor = Executors.newFixedThreadPool(taskSize);
    // 构建完成服务
     CompletionService<Integer> completionService = newExecutorCompletionService<Integer>( executor);
    for (int i = 1; i <= taskSize; i++){
      int sleep = taskSize - i; // 睡眠时间
      int value = i; // 返回结果
      // 向线程池提交任务
      completionService
          .submit(new ReturnAfterSleepCallable(sleep, value));
    }
    // 按照完成顺序,打印结果
    for (int i = 0; i < taskSize; i++){
      try{
        System.out.println(completionService.take().get());
      } catch (InterruptedException e){
        e.printStackTrace();
      } catch (ExecutionException e){
        e.printStackTrace();
      }
    }
    // 所有任务已经完成,关闭线程池
    System.out.println("all over.");
    executor.shutdown();
  }
}

　　可见使用CompletionService不会有TimeOutExeception的问题，不用遍历future列表，不用担心并发修改异常。

3. CompletionService和ExecutorCompletionService的实现

　　JDK源码中CompletionService的javadoc说明如下：

/**
 * A service that decouples the production of new asynchronous tasks
 * from the consumption of the results of completed tasks.  Producers
 * <tt>submit</tt> tasks for execution. Consumers <tt>take</tt>
 * completed tasks and process their results in the order they
 * complete.
 */

　　也就是说， CompletionService实现了生产者提交任务和消费者获取结果的解耦，生产者和消费者都不用关心任务的完成顺序，由 CompletionService来保证，消费者一定是按照任务完成的先后顺序来获取执行结果。ExecutorCompletionService是CompletionService的实现，融合了线程池Executor和阻塞队列BlockingQueue的功能。

public ExecutorCompletionService(Executor executor) {
        if (executor == null)
            throw new NullPointerException();
        this.executor = executor;
        this.aes = (executor instanceof AbstractExecutorService) ?
            (AbstractExecutorService) executor : null;
        this.completionQueue = new LinkedBlockingQueue<Future<V>>();
}

　　到这里可以推测，按照任务的完成顺序获取结果，就是通过阻塞队列实现的，阻塞队列刚好具有这样的性质：阻塞和有序。ExecutorCompletionService 任务的提交和执行都是委托给Executor来完成。当提交某个任务时，该任务首先将被包装为一个QueueingFuture

public Future<V> submit(Callable<V> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<V> f = newTaskFor(task);
        executor.execute(new QueueingFuture(f));
        return f;
}

　　QueueingFuture 是 FutureTask 的一个子类，通过改写 FutureTask 类的 done 方法，可以实现当任务完成时，将结果放入到 BlockingQueue 中。

/**
  * FutureTask extension to enqueue upon completion
  */
private class QueueingFuture extends FutureTask<Void> {
    QueueingFuture(RunnableFuture<V> task) {
      super(task, null);
      this.task = task;
    }
    protected void done() { completionQueue.add(task); }
    private final Future<V> task;
}

　　这里简单说明下：FutureTask.done()，这个方法默认什么都不做，就是一个回调，当提交的线程池中的任务完成时，会被自动调 用。这也就说时候，当任务完成的时候，会自动执行QueueingFuture.done()方法，将返回结果加入到阻塞队列中，加入的顺序就是任务完成 的先后顺序。