Java多线程编程中Future模式的详解

转：http://blog.csdn.net/ghuil/article/details/41048017

1. Future模式核心思想

Future模式的核心在于：去除了主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑（根据《Java程序性能优化》）。

Future模式有点类似于商品订单。在网上购物时，提交订单后，在收货的这段时间里无需一直在家里等候，可以先干别的事情。类推到程序设计中时，当提交请求时，期望得到答复时，如果这个答复可能很慢。传统的时一直等待到这个答复收到时再去做别的事情，但如果利用Future设计模式就无需等待答复的到来，在等待答复的过程中可以干其他事情。

例如如下的请求调用过程时序图。当call请求发出时，需要很长的时间才能返回。左边的图需要一直等待，等返回数据后才能继续其他操作；而右边的Future模式的图中客户端则无需等到可以做其他的事情。服务器段接收到请求后立即返回结果给客户端，这个结果并不是真实的结果（是虚拟的结果），也就是先获得一个假数据，然后执行其他操作。

2. Future模式Java实现

Client的实现

Client主要完成的功能包括：1. 返回一个FutureData；2.开启一个线程用于构造RealData。

[cpp] view plain copy

1. public class Client {  
2.     public Data request(final String string) {  
3.         final FutureData futureData = new FutureData();  
4.           
5.         new Thread(new Runnable() {  
6.             @Override  
7.             public void run() {  
8.                 //RealData的构建很慢，所以放在单独的线程中运行  
9.                 RealData realData = new RealData(string);  
10.                 futureData.setRealData(realData);  
11.             }  
12.         }).start();  
13.           
14.         return futureData; //先直接返回FutureData  
15.     }  
16. }  

Data的实现

无论是FutureData还是RealData都实现该接口。

[java] view plain copy

1. public interface Data {  
2.     String getResult() throws InterruptedException;  
3. }  

FutureData的实现

FutureData是Future模式的关键，它实际上是真实数据RealData的代理，封装了获取RealData的等待过程。

[java] view plain copy

1. //FutureData是Future模式的关键，它实际上是真实数据RealData的代理，封装了获取RealData的等待过程  
2. public class FutureData implements Data {  
3.     RealData realData = null; //FutureData是RealData的封装  
4.     boolean isReady = false;  //是否已经准备好  
5.       
6.     public synchronized void setRealData(RealData realData) {  
7.         if(isReady)  
8.             return;  
9.         this.realData = realData;  
10.         isReady = true;  
11.         notifyAll(); //RealData已经被注入到FutureData中了，通知getResult()方法  
12.     }  
13.   
14.     @Override  
15.     public synchronized String getResult() throws InterruptedException {  
16.         if(!isReady) {  
17.             wait(); //一直等到RealData注入到FutureData中  
18.         }  
19.         return realData.getResult();   
20.     }  
21. }  

RealData的实现

RealData是最终需要使用的数据，它的构造函数很慢。

[java] view plain copy

1. public class RealData implements Data {  
2.     protected String data;  
3.   
4.     public RealData(String data) {  
5.         //利用sleep方法来表示RealData构造过程是非常缓慢的  
6.         try {  
7.             Thread.sleep(1000);  
8.         } catch (InterruptedException e) {  
9.             e.printStackTrace();  
10.         }  
11.         this.data = data;  
12.     }  
13.   
14.     @Override  
15.     public String getResult() {  
16.         return data;  
17.     }  
18. }  

测试运行

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

[java] view plain copy

1. public class Application {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         Client client = new Client();  
4.         //这里会立即返回，因为获取的是FutureData，而非RealData  
5.         Data data = client.request("name");  
6.         //这里可以用一个sleep代替对其他业务逻辑的处理  
7.         //在处理这些业务逻辑过程中，RealData也正在创建，从而充分了利用等待时间  
8.         Thread.sleep(2000);  
9.         //使用真实数据  
10.         System.out.println("数据="+data.getResult());  
11.     }  
12. }  

3. Future模式的JDK内置实现

由于Future是非常常用的多线程设计模式，因此在JDK中内置了Future模式的实现。这些类在java.util.concurrent包里面。其中最为重要的是FutureTask类，它实现了Runnable接口，作为单独的线程运行。在其run()方法中，通过Sync内部类调用Callable接口，并维护Callable接口的返回对象。当使用FutureTask.get()方法时，将返回Callable接口的返回对象。同样，针对上述的实例，如果使用JDK自带的实现，则需要作如下调整。

首先，Data接口和FutureData就不需要了，JDK帮我们实现了。

其次，RealData改为这样：

[java] view plain copy

1. import java.util.concurrent.Callable;  
2.   
3. public class RealData implements Callable<String> {  
4.     protected String data;  
5.   
6.     public RealData(String data) {  
7.         this.data = data;  
8.     }  
9.   
10.     @Override  
11.     public String call() throws Exception {  
12.         //利用sleep方法来表示真是业务是非常缓慢的  
13.         try {  
14.             Thread.sleep(1000);  
15.         } catch (InterruptedException e) {  
16.             e.printStackTrace();  
17.         }  
18.         return data;  
19.     }  
20. }  

最后，在测试运行时，这样调用：

[java] view plain copy

1. import java.util.concurrent.ExecutorService;  
2. import java.util.concurrent.Executors;  
3. import java.util.concurrent.FutureTask;  
4.   
5. public class Application {  
6.     public static void main(String[] args) throws Exception {  
7.         FutureTask<String> futureTask =   
8.                 new FutureTask<String>(new RealData("name"));  
9.         ExecutorService executor =   
10.                 Executors.newFixedThreadPool(1); //使用线程池  
11.         //执行FutureTask，相当于上例中的client.request("name")发送请求  
12.         executor.submit(futureTask);  
13.         //这里可以用一个sleep代替对其他业务逻辑的处理  
14.         //在处理这些业务逻辑过程中，RealData也正在创建，从而充分了利用等待时间  
15.         Thread.sleep(2000);  
16.         //使用真实数据  
17.         //如果call()没有执行完成依然会等待  
18.         System.out.println("数据=" + futureTask.get());  
19.     }  
20. }