Java Future 模式

@qxr

1、简单介绍

在并发编程中，我们经常用到非阻塞的模型，在之前的多线程的三种实现中，不管是继承 Thread 类试试实现 Runnable 接口，都无法保证获取到之前的执行结果。通过实现 Callback ，并用 Future 可以用来接收多线程的执行结果。

Future模式有点类似于商品订单。在网上购物时，提交订单后，在收货的这段时间里无需一直在家里等候，可以先干别的事情。类推到程序设计中时，当提交请求时，期望得到答复时，如果这个答复可能很慢。传统的时一直等待到这个答复收到时再去做别的事情，但如果利用Future设计模式就无需等待答复的到来，在等待答复的过程中可以干其他事情。

Future 表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加 Callback 以便在任务执行成功或失败后作出对应的操作。Future中心思想就是：去除了主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑。

2、串行执行与异步执行的流程对比

3、Future的核心结构图

4、Future异步计算示例

public class AsyncCompute {
	
	//线程池
	private ExecutorService executorService;
	
	//保存异步计算的Future
	private FutureContext<String> context;
	
	public AsyncCompute(){
		this.executorService = Executors.newFixedThreadPool(100);
		this.context = new FutureContext<String>();
	}
	
	public static void main(String[] args) {
		//启动异步计算
		AsyncCompute asyncCompute = new AsyncCompute();
		asyncCompute.startAsyncCompution();
		
		//启动异步计算结果输出线程
		OutputResult output = new OutputResult();
		output.setContext(asyncCompute.getContext());
		new Thread(output).start();
		
	}
	
	public FutureContext<String> getContext() {
		return context;
	}
 
	public void setContext(FutureContext<String> context) {
		this.context = context;
	}
 
	private void startAsyncCompution() {
		
        /** 
         * 开启100个异步计算，每个异步计算线程随机sleep几秒来模拟计算耗时。 
         */  
        final Random random = new Random();  
        for (int i = 0; i < 100; i++) {  
            Future<String> future = this.executorService  
                    .submit(new Callable<String>() {  
                        @Override  
                        public String call() throws Exception {  
                            int randomInt = random.nextInt(5);  
                            Thread.sleep(randomInt * 1000);  
                            return "" + randomInt;  
                       }  
                    });  
            //每个异步计算的结果存放在context中  
            this.context.addFuture(future);  
        }

	}
 
	public static class FutureContext<T>{
		
	     private List<Future<T>> futureList  = new ArrayList<Future<T>>();
		
             public void addFuture(Future<T> future) {  
    	         this.futureList.add(future);  
             }  
             public List<Future<T>> getFutureList() {  
                 return this.futureList;  
             } 
		
	}
	
	public static class OutputResult implements Runnable{
		
		private FutureContext<String> context;		
 
		public FutureContext<String> getContext() {
			return context;
		}
 
		public void setContext(FutureContext<String> context) {
			this.context = context;
		}
 
		@Override
		public void run() {
			
	           System.out.println("start to output result:");  
	           List<Future<String>> list = this.context.getFutureList();  
	         
	           for (Future<String> future : list) {  
	                 this.outputResultFromFuture(future);  
	           }  	             
	           System.out.println("finish to output result.");
 
		}
		
	    private void outputResultFromFuture(Future<String> future) {  
              try {  
                   while (true) {  
                       if (future.isDone() && !future.isCancelled()) {  
                           System.out.println("Future:" + future + ",Result:"  
                                   + future.get());  
                           break;  
                       } else {  
                           Thread.sleep(1000);  
                      }  
                   }  
               } catch (Exception e) {  
                   e.printStackTrace();  
               }  
	    } 
 
		
	}
	
}

输出结果

start to output result:
Future:java.util.concurrent.FutureTask@1cb20da,Result:3
Future:java.util.concurrent.FutureTask@2b6b0c24,Result:4
Future:java.util.concurrent.FutureTask@ea25c1,Result:1
Future:java.util.concurrent.FutureTask@c54a25f,Result:3
Future:java.util.concurrent.FutureTask@870114c,Result:4
Future:java.util.concurrent.FutureTask@757f98e7,Result:4
Future:java.util.concurrent.FutureTask@c0fa1f5,Result:0
Future:java.util.concurrent.FutureTask@5651e202,Result:3
......
finish to output result.