java多线程模式：Future模式

Future模式类似于商品订单。当在网购时，下了一个订单后，我们可以做其他事情，等待商品送货上门即可。或者就像在页面上使用ajax请求的时候，页面的一些内容是异步的向后台发请求，我们可以正常的浏览页面其他内容。Future模式的图如下。



 客户端发送一个耗时请求，服务端不需等待该数据处理完成便立即返回一个伪造的代理数据，先去执行其他的若干操作后，再去调用服务器已经完成组装的真实数据。该模式充分利用了等待的时间片段。

代码如下：

Data接口，FutureData和RealData的超类

public interface Data {

Object getResult();

}

真实数据的代理类FutureData，它需要真实数据的引用，因为需要通过它来获取真实数据

public class FutureData implements Data {

private RealData realData;

private Boolean isDone = false;

public synchronized void setRealData(RealData realData) {
if (isDone) {
return;
}
this.realData = realData;
isDone = true;
notifyAll();
}

@Override
public synchronized Object getResult() {
while (!isDone) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return realData.getResult();
}

}

setRealData方法和getResult方法是互斥的，当调用getReult方法获取处理结果时候，需要等待setRealData方法执行完毕，将结果设置成功。

真实数据RealData：

public class RealData implements Data {

private Object result;

private Object param;

public RealData(Object param) {
this.param = param;
}

@Override
public Object getResult() {

return result;
}

private void setResult(Object result) {
this.result = result;
}

public void Handle() {
try {
//假装在忙
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
setResult(param.toString() + ": 处理结果");
}

}

future客户端 ：

public class FutureClient {

FutureData futureData = new FutureData();
public Data request(final Object param) {

new Thread(new Runnable() {

@Override
public void run() {
RealData realData = new RealData(param);
realData.Handle();
futureData.setRealData(realData);

}
}).start();

return futureData;
}

}

该处启用了一个线程来处理数据，也就是获取RealData，返回了FutureData，而FutureData又包含了RealData的引用，可以获取数据处理结果。

接下来做个测试：

public class FutureDataTest {

public static void main(String[] args) {

FutureClient fc = new FutureClient();
Data futureData = fc.request("参数");
String a = "做我自己的事情...";
System.out.println(a);
System.out.println(a + futureData.getResult());

}
}

然而，在使用过程中，我们不需要写复杂的这个过程，jdk提供了Future实现方式。

public static void main(String[] args) {

ExecutorService executor = Executors.newCachedThreadPool();
Future<String> future = executor.submit(new Callable<String>() {

public String call() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "future处理结果";
}});
String a = "做我自己的事情...";
System.out.println(a);
while(true) {
if (future.isDone()) {
String res = null;
try {
res = future.get();
a = a + res;
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
break;
}
}
System.out.println(a);
executor.shutdown();

}

Callable接口，是不是感觉和Runable接口有些像，只不过Runable接口需要重写run方法，而Callable接口需要重写calll方法，并且call方法具有返回值。这也说明了两个接口的区别：

在并发编程时，使用runnable，然后扔给线程池完事，这种情况下不需要线程的结果。所以run的返回值是void类型。而callable是需要返回结果的。

你可能会有疑问：再获取真实数据时不是仍然需要等待数据处理完吗？要知道，你可以用这个时间做一些其他事情，等到真正需要真实数据时候再去获取。