并发程序设计模式之Future模式

Future模式有点类似商品订单。比如在进行网上购物时，当看中某一件商品时，就可以提交订单。当订单处理完毕后，便可在家等待商品送货上门。卖家根据订单从仓库里取货，并配送到客户手上。在大部分情况下，商家对订单的处理并不那么快，在这段时间内，客户可以处理其他事情

类似地，当某一段程序提交了一个请求，期望得到一个答复。但服务程序对这个请求可能很慢，在传统的单线程环境下，调用函数是同步的，也就是说它必须等到服务程序返回结果后，才能进行其他处理。而在Future模式下，调用方式改为异步，而原先等待返回的时间段，在主调用函数中，则可用于处理其他事物。如图所示，是一个传统的程序调用的流程

如上图所示，客户端发出call请求，这个请求需要相当长一段时间才能返回。客户端一直等待，直到数据返回，随后，再进行其他任务的处理。而使用Future模式替换原来的实现方式，可以改进调用过程。如图

上图显示了一个广义Future模式的实现，从Data Future对象可以看到，虽然call本身仍然需要很长一段时间来处理程序。但是，服务程序不等数据处理完成便立即返回客户端一个伪造的数组（相当于商品的订单，而不是商品本身），实现了Future模式的客户端拿到这个返回结果后，不急于对其进行处理，而去调用其他业务逻辑，充分利用了等待时间，这就是Future模式的核心所在

1.  Future模式核心结构

Future模式的主要参与者有：Main、Client、Data、FutureData、RealData

• Main：系统启动，调用Client发出请求
• Client：返回Data对象，立即返回FutureData，并开启ClientThread线程装配RealData
• Data：返回数据的接口
• FutureData：Future数据，构造很快，但是是一个虚拟的数据，需要装配RealData
• RealData：真实数据，其构造是比较慢的

Future模式的类结构图如图

2. Future模式的代码实现

Data是一个接口，提供了getResult()方法，无论FutureData或者RealData都实现了这个接口：

package com.joyhwong;public interface Data {String getResult();}

RealData是最终需要使用的数据模型，它的构造很慢。这里用sleep()方法模拟这个过程：

package com.joyhwong;public class RealData implements Data {protected final String result;public RealData(String para) {StringBuffer sb = new StringBuffer();for (int i = 0; i < 10; i++) {sb.append(para);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}result = sb.toString();}@Overridepublic String getResult() {return result;}}

FutureData实现了一个快速返回的RealData包装。它只是一个包装，或者说是一个RealData的虚拟实现。因此，它可以很快地被构造并返回。当使用FutureData的getResult()方法时，程序会阻塞，等待RealData被注入到程序中，才使用RealData的getResult()方法返回

package com.joyhwong;public class FutureData implements Data {protected RealData realdata = null;protected boolean isReady = false;public synchronized void setRealData(RealData realdata) {if (isReady) {return;}this.realdata = realdata;isReady = true;notifyAll();}@Overridepublic synchronized String getResult() {while (!isReady) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}return realdata.result;}}

Client主要实现了获取FutureData，开启构造RealData的线程，并在接受请求后，很快地返回FutureData

package com.joyhwong;public class Client {public Data request(final String queryStr) {final FutureData future = new FutureData();new Thread() {public void run() {RealData realdata = new RealData(queryStr);future.setRealData(realdata);}}.start();return future;}}

Main函数主要负责调用Client发起请求，并使用返回的数据：

package com.joyhwong;public class Main {public static void main(String[] args) {Client client = new Client();Data data = client.request("name");System.out.println("请求完毕");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("数据 = " + data.getResult());}}

运行main方法，经历几秒钟的等待，输出如下

3. JDK的内置实现

在JDK的并发包中，就已经内置了一种Future模式的实现，JDK中的实现是相当复杂的，并且提供了更为丰富的线程控制功能

在JDK的实现中，有关实现Future模式的核心结构如图

其中，最为重要的模块是FutureTask类，它实现了Runnable接口，作为单独的线程运行。在其run()方法中，通过Sync内部类，调用Callable接口，并维护Callable接口的返回对象。当使用FutureTask.get()方法时，将返回Callable接口的返回对象。除此以外，通过Future接口提供的一系列方法，FutureTask还可以对任务本身进行其他控制操作

Callable接口使一个用户自定义的实现。在应用程序中，通过实现Callable接口的call()方法，执行FutureTask的实际工作内容和返回对象

可以使用JDK内置的Future模式实现本小节中的程序功能。首先需要实现Callable接口，实现具体的业务逻辑。这里用RealData来实现这个接口

package com.joyhwong;import java.util.concurrent.Callable;public class RealData implements Callable<String> {private String para;public RealData(String para) {this.para = para;}@Overridepublic String call() throws Exception {StringBuffer sb = new StringBuffer();for (int i = 0; i < 10; i++) {sb.append(para);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}return sb.toString();}}

在这个改进中，RealData的构造变得非常快，因为其主要业务逻辑被移动到call()方法内，并通过call()方法返回

在main方法中，直接通过RealData构造FutureTask，并将其作为单独的线程运行。在提交请求后，执行其他业务逻辑，最后，通过FutureTask.get()方法，得到RealData的执行结果

package com.joyhwong;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.FutureTask;public class Main {public static void main(String[] args) throws InterruptedException, ExecutionException {FutureTask<String> future = new FutureTask<>(new RealData("a"));ExecutorService executor = Executors.newFixedThreadPool(1);executor.submit(future);System.out.println("请求完毕");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("数据 = " + future.get());executor.shutdown();}}

Future模式的核心在于去掉了主函数中的等待时间，并使得原本需要等待的时间段可以用于处理其他的业务逻辑，从而充分利用计算机资源