future的原理

1、主进程不用关心和等待实际处理的情况
背景：主线程发送一个请求去买包子（实际会花费2秒钟），期间需要修车（需要5秒钟），需要在最短时间内完成任务。理想状态是5秒钟。

主线程需要：发送安排一个人去买包子，一个人修车
public static void main(String[] args) throws Exception {
FutureClient fu = new FutureClient();
System.out.println(“主进程发送请求”);
Data data = fu.request(“请求参数”);
new Thread(new Runnable() {
@Override
public void run() {
int count = 0;
while(count < 5)
{
try {
Thread.sleep(1000);
count++;
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("…");
}
}
}).start();
String result = data.getRequst();
System.out.println(“结果回来了：”+ result);
}

执行结果：
主进程发送请求
真实查询参数已经接受，准备处理请求
…
…
真实数据处理完毕，返回结果给主进程
结果回来了：success
…
…
…

辅助类：
public interface Data {
String getRequst();
}

买包子：
public class RealData implements Data{

private String result;
public RealData(String param) {
	System.out.println("真实查询参数已经接受，准备处理请求");
	try {
		Thread.sleep(2000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	System.out.println("真实数据处理完毕，返回结果给主进程");
	result = "success";
}
@Override
public String getRequst() {
	return result;
}

}

买包子的路上：
public class FutrueData implements Data{
boolean isReady = false;
private RealData realData;
@Override
public synchronized String getRequst() {
while (!isReady)
{
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return this.realData.getRequst();
}
public synchronized void setData(RealData realData) {
if (isReady)
{
return;
}
this.realData = realData;
isReady = true;
notify();
}
}

创建买包子的任务：
public class FutureClient {
public Data request(final String param)
{
final FutrueData data = new FutrueData();
//先定义一个数据模型返回去，实际的在线程中执行。达到不阻塞主线程
new Thread(new Runnable() {
@Override
public void run() {
synchronized (data) {
final RealData realData = new RealData(param);
data.setData(realData);
}
}
}).start();
return data;
}
}