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

ゝ一纸荒年。 2022-06-06 13:35 201阅读 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][view plain][ copy][view plain][ print][view plain][?][view plain]

1.  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.

（2）Client的实现：

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

1.  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.

（3）Data的实现：

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

1.  package tgb;  
2.    
3.  public interface Data \{  
4.    
5.      public  String getResult();  
6.  \}  
7.

（4）FutureData：

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

1.  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.

（5）RealData实现：

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

1.  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.

**注意：**

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

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

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

[SouthEast]: /images/20220606/9a4562ae995b476c9f00d81a6f8c653d.png
[SouthEast 1]: /images/20220606/129da6436a59465c8507f56c02ee5194.png
[view plain]: http://blog.csdn.net/lmdcszh/article/details/39696357#

发表评论取消回复

表情：

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

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

相关阅读

相关并发编程——Future & CompletableFuture

文章目录 Future介绍 FutureTask使用 FutureTask 分析 CompletableFuture Completa

Love The Way You Lie/ 2023年10月16日 12:13/ 0 赞/ 59 阅读

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

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

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

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

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

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

相关并发编程实现模型之（二）Master-Worker模式

Master-Worker模式是常用的并行模式之一，它的核心思想是，系统有两个进程协作工作：Master进程，负责接收和分配任务；Worker进程，负责处理子任务。当Worke

不念不忘少年蓝@/ 2022年06月06日 13:51/ 0 赞/ 192 阅读

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

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

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

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

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

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

相关并发编程实现模型之（三）Producer-Consumer模式

生产者-消费模式，通常有两类线程，即若干个生产者线程和若干个消费者线程。生产者线程负责提交用户请求，消费者线程负责具体处理生产者提交的任务。两者之间通过共享内存缓冲去进行通信。

╰+攻爆jí腚メ/ 2022年06月05日 00:22/ 0 赞/ 171 阅读

相关高并发编程学习笔记(7)-Future设计模式

Future设计模式如果有任务执行需要比较长的时间，通常需要等待任务执行结束或者出错才能返回结果，在此期间调用者只能陷入阻塞苦苦等待，对此，Future设计模式提供了一

末蓝、/ 2022年04月11日 10:19/ 0 赞/ 262 阅读

相关 Java Future并发模式

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

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

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

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

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