@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.