CompletionService 简介

        当向Executor提交批处理任务时，而且但愿在它们完成后得到结果，若是用FutureTask，你能够循环获取task，并用future.get()去获取结果，可是若是这个task没有完成，你就得阻塞在这里，这个实效性不高，其实在不少场合，其实你拿第一个任务结果时，此时结果并无生成并阻塞，其实在阻塞在第一个任务时，第二个task的任务已经早就完成了，显然这种状况用future task不合适的，效率也不高。
       本身维护list和CompletionService的区别：

1. 从list中遍历的每一个Future对象并不必定处于完成状态，这时调用get()方法就会被阻塞住，若是系统是设计成每一个线程完成后就能根据其结果继续作后面的事，这样对于处于list后面的可是先完成的线程就会增长了额外的等待时间。
2. 而CompletionService的实现是维护一个保存Future对象的BlockingQueue。只有当这个Future对象状态是结束的时候，才会加入到这个Queue中，take()方法其实就是Producer-Consumer中的Consumer。它会从Queue中取出Future对象，若是Queue是空的，就会阻塞在那里，直到有完成的Future对象加入到Queue中。

       CompletionService采起的是BlockingQueue<Future<V>>无界队列来管理Future。则有一个线程执行完毕把返回结果放到BlockingQueue<Future<V>>里面。就能够经过completionServcie.take().get()取出结果。

         方法区别：

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

如下是jdk关于CompletionService的简介：

•    public interface CompletionService<V>
• 将生产新的异步任务与使用已完成任务的结果分离开来的服务。生产者 submit 执行的任务。使用者 take 已完成的任务，并按照完成这些任务的顺序处理它们的结果。例如，CompletionService 能够用来管理异步 IO ，执行读操做的任务做为程序或系统的一部分提交，而后，当完成读操做时，会在程序的不一样部分执行其余操做，执行操做的顺序可能与所请求的顺序不一样。
  
• 一般，CompletionService 依赖于一个单独的 Executor 来实际执行任务，在这种状况下，CompletionService 只管理一个内部完成队列。ExecutorCompletionService 类提供了此方法的一个实现。 
• 内存一致性效果：线程中向 CompletionService 提交任务以前的操做 happen-before 该任务执行的操做，后者依次 happen-before 紧跟在从对应 take() 成功返回的操做。 
  

废话少说，直接看代码：

package com.lucky.concurrent;

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;

public class CompletionServiceDemo {

	public static class Task implements Callable<Integer> {
		private int i;

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

		@Override
		public Integer call() throws Exception {
			Thread.sleep(new Random().nextInt(5000));
			System.out.println(Thread.currentThread().getName() + "   " + i);
			return i;
		}
	}

	public void run() {
		ExecutorService pool = Executors.newFixedThreadPool(10);
		CompletionService<Integer> completionServcie = new ExecutorCompletionService<Integer>(
				pool);
		try {
			for (int i = 0; i < 10; i++) {
				completionServcie.submit(new CompletionServiceDemo.Task(i));
			}
			for (int i = 0; i < 10; i++) {
				// take 方法等待下一个结果并返回 Future 对象。
				// poll 不等待，有结果就返回一个 Future 对象，不然返回 null。
				System.out.println(completionServcie.take().get());
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		} finally {
			pool.shutdown();
		}
	}

	public static void main(String[] args) {
		new CompletionServiceDemo().run();
	}
}

直接结果：

从结果中不难看出。只要有一个线程执行完毕后，主程序就立马获取结果。