并发模型：Future模式

 多线程开发可以更好的发挥多核cpu性能，常用的多线程设计模式有：Future、Master-Worker、Guard Susperionsion、不变、生产者-消费者 模式；jdk除了定义了若干并发的数据结构，也内置了多线程框架和各种线程池；    锁（分为内部锁、重入锁、读写锁）、ThreadLocal、信号量等在并发控制中发挥着巨大的作用。这里重点介绍第一种并发——Future模型。

一、什么是Future模型：

    该模型是将异步请求和代理模式联合的模型产物。类似商品订单模型。见下图：

    客户端发送一个长时间的请求，服务端不需等待该数据处理完成便立即返回一个伪造的代理数据（相当于商品订单，不是商品本身），用户也无需等待，先去执行其他的若干操作后，再去调用服务器已经完成组装的真实数据。该模型充分利用了等待的时间片段。

 二、Future模式的核心结构：

    

Main：启动系统，调用Client发出请求；

Client：返回Data对象，理解返回FutureData，并开启ClientThread线程装配RealData；

Data：返回数据的接口；

FutureData：Future数据，构造很快，但是是一个虚拟的数据，需要装配RealData；

RealData：真实数据，构造比较慢。

三、Future模式的代码实现：

（1）Main函数：

[java]  view plain   copy

1. <span style="font-size:18px;">package tgb;  
2.   
3. public class Main {  
4.       
5.     public static void main(String[] args){  
6.         Client client = new Client();  
7.         //理解返回一个FutureData  
8.         Data data = client.request("name");  
9.         System.out.println("请求完毕！");  
10.           
11.         try{  
12.               
13.             //处理其他业务  
14.             //这个过程中，真是数据RealData组装完成，重复利用等待时间  
15.             Thread.sleep(2000);           
16.               
17.         }catch (Exception e){  
18.               
19.         }  
20.           
21.         //真实数据  
22.         System.out.println("数据 = "+ data.getResult());  
23.           
24.           
25.     }  
26.       
27. }  
28. </span>  

（2）Client的实现：

[java]  view plain   copy

1. <span style="font-size:18px;">package tgb;  
2.   
3. public class Client {  
4.   
5.     public Data request(final String queryStr){  
6.         final FutureData future = new FutureData();  
7.         //开启一个新的线程来构造真实数据  
8.         new Thread(){  
9.             public void run(){  
10.                 RealData realData = new RealData(queryStr);  
11.                 future.setRealData(realData);           }  
12.         }.start();  
13.         return future;  
14.     }  
15. }  
16. </span>  

（3）Data的实现：

[java]  view plain   copy

1. <span style="font-size:18px;">package tgb;  
2.   
3. public interface Data {  
4.   
5.     public  String getResult();  
6. }  
7. </span>  

（4）FutureData：

[java]  view plain   copy

1. <span style="font-size:18px;">package tgb;  
2.   
3. /** 
4.  * 是对RealData的一个包装 
5.  * @author limin 
6.  * 
7.  */  
8. public class FutureData implements Data {  
9.   
10.     protected RealData realData =null;  
11.     protected boolean isReady = false;  
12.     public synchronized void setRealData(RealData realData){  
13.         if(isReady){  
14.             return;  
15.         }  
16.         this.realData=realData;  
17.         isReady=true;  
18.         notifyAll();  
19.           
20.     }  
21.       
22.     @Override  
23.     public  synchronized  String getResult() {  
24.         while(!isReady){  
25.             try{  
26.                 wait();  
27.             }catch (Exception e){  
28.                   
29.             }  
30.         }  
31.         return realData.result;  
32.     }  
33.   
34. }  
35. </span>  

（5）RealData实现：

[java]  view plain   copy

1. <span style="font-size:18px;">package tgb;  
2.   
3. public class RealData implements Data {  
4.     protected  String  result;  
5.       
6.     public RealData(String para){  
7.          //构造比较慢  
8.         StringBuffer sb= new StringBuffer();  
9.         for(int i=0;i<10;i++){  
10.             sb.append(para);  
11.             try{  
12.                 Thread.sleep(1000);  
13.             }catch(Exception e){  
14.                   
15.             }  
16.             result= sb.toString();  
17.         }  
18.     }  
19.       
20.       
21.       
22.     @Override  
23.     public String getResult() {  
24.   
25.         return result;  
26.     }  
27.   
28. }  
29. </span>  

注意：

    FutureData是对RealData的包装，是dui真实数据的一个代理，封装了获取真实数据的等待过程。它们都实现了共同的接口，所以，针对客户端程序组是没有区别的；

    客户端在调用的方法中，单独启用一个线程来完成真实数据的组织，这对调用客户端的main函数式封闭的；

    因为咋FutureData中的notifyAll和wait函数，主程序会等待组装完成后再会继续主进程，也就是如果没有组装完成，main函数会一直等待。

原文链接：https://blog.csdn.net/lmdcszh/article/details/39696357