Callable，Future，FutrueTask，CompletionService 详解

package com.dy.pool;


import java.util.concurrent.*;

/**
 * 1: Callable<V> 返回结果而且可能抛出异常的任务。实现者定义了一个不带任何参数的叫作 call 的方法。

      Callable 接口相似于 Runnable，二者都是为那些其实例可能被另外一个线程执行的类设计的。

      可是 Runnable 不会返回结果，而且没法抛出通过检查的异常。


 2:  Future<V> 表示异步计算的结果
     Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。

 3:  CompletionService<V> 将生产新的异步任务与使用已完成任务的结果分离开来的服务 ,

 *   生产者 submit 执行的任务。使用者 take 已完成的任务，并按照完成这些任务的顺序处理它们的结果。
 *
 *
 *   4：FutureTask<V> 可取消的异步计算。实现了RunbaleFuture,
 *
 *   RunbaleFuture 继承了Future和Runbale,因此FutureTask<V>能够当作一个线程去提交或执行。
 *
 *   返回FutureTask的操做也能够用Future来接受
 *
 *    利用开始和取消计算的方法、查询计算是否完成的方法和获取计算结果的方法，此类提供了对 Future 的基本实现。
 *
 *    仅在计算完成时才能获取结果；若是计算还没有完成，则阻塞 get 方法。一旦计算完成，就不能再从新开始或取消计算。

     可以使用 FutureTask 包装 Callable 或 Runnable 对象。由于 FutureTask 实现了 Runnable，

      因此可将 FutureTask 提交给 Executor 执行。
 *
 * @author dengyang
 *
 * @2012-4-13下午12:57:57
 */
public class CallableAndFuture {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		/**
		 * Future使用
		 */
		ExecutorService threadPool = Executors.newSingleThreadExecutor();
		
		 Future<String> future = threadPool.submit(new Callable<String>(){
			public String call() throws Exception {
				Thread.sleep(1000);
				return "I am dengyang";
			}
		});

		System.out.println("我先去作其余事情了...");
		 try {
			System.out.println("The Callable return :"+future.get());
//			System.out.println("The Callable return :"+future.get(100,TimeUnit.SECONDS));
		}  catch (Exception e) {
			e.printStackTrace();
		 }
		threadPool.shutdown();

		/**
		 * FutureTask使用
                */
		ExecutorService executor = Executors.newFixedThreadPool(3);
		FutureTask<String> futureTask =
				new FutureTask<String>(new Callable<String>() {
					public String call() {
						return "我执行完了";
					}});
//		executor.submit(futureTask);
		executor.execute(futureTask);
		System.out.println("线程在执行FutureTask,我先去处理别的事情了");
		try {
			System.out.println("futureTask return:"+futureTask.get());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		executor.shutdown();
		 /*
		    CompletionService使用
		  * 有多个线程，哪一个先返回数据，就先获取哪一个
		  */
		 ExecutorService threadPool2 = Executors.newFixedThreadPool(10);
		 CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool2);
		 for(int i=0;i<10;i++){
			 final int seq = i;
			 completionService.submit(new Callable<Integer>(){
					public Integer call() throws Exception {
						return seq;
					}
				});
		 }
		System.out.println("多线程执行任务时,我先去作其余事情了...");
		 try {
			 System.out.println("the first result of The Callable return :"+completionService.take().get());
			 for(int i=0;i<10;i++){
				 System.out.println(" The Callable return :"+completionService.take().get());
			 }
		}  catch (Exception e) {
			e.printStackTrace();
		}
		 threadPool2.shutdown();
	}
}

使用Callable，Future返回结果 
Future<V>表明一个异步执行的操做，经过get()方法能够得到操做的结果，若是异步操做尚未完成，则，get()会使当 前线程阻塞。FutureTask<V>实现了Future<V>和Runable<V>。Callable表明一 个有返回值得操做。

ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。若是Executor后台线程池尚未完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。 

FutureTask使用过程当中，咱们一般能够迭代FutureTask的数组，若是任务尚未完成则当前线程会阻塞，

若是咱们希 望任意字任务完成后就把其结果加到result中，而不用依次等待每一个任务完成，可使CompletionService。

生产者submit()执行 的任务。使用者take()已完成的任务，并按照完成这些任务的顺序处理它们的结果 。

也就是调用CompletionService的take方法是，会返回按完成顺序放回任务的结果，

CompletionService内部维护了一个 阻塞队列BlockingQueue，若是没有任务完成，take()方法也会阻塞。 

类模型：