并发模型（一）——Future模式

深碍√TFBOYSˉ_ 2021-09-14 06:24 339阅读 0赞

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

**一、什么是Future模型：**

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

![SouthEast][]

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

** 二、Future模式的核心结构：**

![SouthEast 1][]

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

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

Data：返回数据的接口；

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

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

**三、Future模式的代码实现：**

（1）Main函数：

**\[java\]**  [view plain][]   [copy][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain]

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函数会一直等待。

[SouthEast]: /images/20210527/534ecf47b4cf481282a81ee6dd912b33.png
[SouthEast 1]: /images/20210527/e945c4dfdcd94acdb590b0bc1e35a2d1.png
[view plain]: http://blog.csdn.net/lmdcszh/article/details/39696357#

发表评论取消回复

表情：

评论列表（有 0 条评论，339人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java 并发编程面试题——Future 模式

目录 1.什么是 Future 模式？Java 中是如何实现的？ 2.Callable、Future 与 FutureTask 分别是什么？ 2.

迷南。/ 2023年10月09日 17:49/ 0 赞/ 55 阅读

相关 future模式

DK-Future 模式和实现最近的项目用到了多线程，发现java.util.concurrent.Future蛮好用的。像平时，写多线程一般使用Thread/Ru

旧城等待，/ 2022年08月10日 05:52/ 0 赞/ 187 阅读

相关 Future 模式详解（并发使用）

我觉得很多讲Future模式的文章并没有深刻理解Future模式，其实Future模式只是生产者-消费者模型的扩展。经典“生产者-消费者”模型中消息的生产者不关心消费者何时处理

浅浅的花香味﹌/ 2022年07月11日 04:29/ 0 赞/ 176 阅读

相关 future模式

参考：[http://www.cnblogs.com/sigm/p/6221946.html][http_www.cnblogs.com_sigm_p_6221946.html

快来打我*/ 2022年06月13日 07:17/ 0 赞/ 191 阅读

相关并发编程实现模型之（一）Future模式

多线程开发可以更好的发挥多核cpu性能，常用的多线程设计模式有：Future、Master-Worker、Guard Susperionsion、不变、生产者-消费者模式；j

ゝ一纸荒年。/ 2022年06月06日 13:35/ 0 赞/ 200 阅读

相关并发编程(11)-Future模式

Future模式有点类似于商品订单。比如在网购时，当看中某一个商品时，就可以提交订单，当订单处理完成后，在家里等待商品送货上门即可。或者说更形象的我们发送Ajax请求的时候，页

╰半夏微凉°/ 2022年06月06日 09:40/ 0 赞/ 183 阅读

相关 Future模式

Future模式是多线程开发中常见的设计模式，它的核心思想是异步调用。对于Future模式来说，它无法立即返回你需要的数据，但是它会返回一个契约，将来你可以凭借这个契约去获取你

快来打我*/ 2022年05月15日 01:23/ 0 赞/ 422 阅读

相关 Future模式

是一种异步处理的模式，某个线程获取另外一个线程的执行结果，由于另外一个线程执行的比较慢，所以立马返回了一个空数据的Future对象。然后在该对象的get()方法上阻塞，直到有数

旧城等待，/ 2022年05月14日 00:15/ 0 赞/ 207 阅读

相关 Java Future并发模式

Future与线程池区别 Future跟Callable一样都会返回值，而线程池不会返回值 CompletableFuture 直接跳到Completabl

妖狐艹你老母/ 2022年02月05日 07:59/ 0 赞/ 241 阅读

相关并发模型（一）——Future模式

多线程开发可以更好的发挥多核cpu性能，常用的多线程设计模式有：Future、Master-Worker、Guard Susperionsion、不变、生产者-消费者模式；

深碍√TFBOYSˉ_/ 2021年09月14日 06:24/ 0 赞/ 340 阅读