并发程序设计模式之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();
	}

	@Override
	public 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();
	}

	@Override
	public 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;
	}
	@Override
	public 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模式的核心在于去掉了主函数中的等待时间，并使得原本需要等待的时间段可以用于处理其他的业务逻辑，从而充分利用计算机资源