14.Java中的Future模式

jdk1.7.0_79

  本文实际上是对上文《13.ThreadPoolExecutor线程池之submit方法》的一个延续或者一个补充。在上文中提到的submit方法里出现了FutureTask,这不得不停止脚步将方向转向Java的Future模式。

  Future是并发编程中的一种设计模式,对于多线程来说,线程A需要等待线程B的结果,它没必要一直等待B,可以先拿到一个未来的Future,等B有了结果后再取真实的结果。

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(callable);    //主线程需要callable线程的结果,先拿到一个未来的Future
System.out.println(future.get());    //有了结果后再根据get方法取真实的结果,当然如果此时callable线程如果没有执行完get方法会阻塞执行完,如果执行完则直接返回结果或抛出异常

   也就是说,Future它代表一个异步计算的结果。

  上面就代表了Future模式的执行原理,根据网上的例子,我们可以来自己实现一个Future模式。

1 package com.future;
2 
3 /**
4  * 数据结果
5  * Created by yulinfeng on 6/18/17.
6  */
7 public interface Data {
8     String getResult() throws InterruptedException;
9 }
 1 package com.future;
 2 
 3 /**
 4  * 结果的真实计算过程
 5  * Created by yulinfeng on 6/18/17.
 6  */
 7 public class RealData implements Data {
 8     protected String data;
 9 
10     public RealData(String data) {
11         try {
12             System.out.println("正在计算结果");
13             Thread.sleep(3000);     //模拟计算
14         } catch (InterruptedException e) {
15             e.printStackTrace();
16         }
17         this.data = data + “ world”;
18     }
19 
20     public String getResult() throws InterruptedException {
21         return data;
22     }
23 }
 1 package com.future;
 2 
 3 /**
 4  * 真实结果RealData的代理
 5  * Created by yulinfeng on 6/18/17.
 6  */
 7 public class FutureData implements Data {
 8     RealData realData = null;   //对RealData的封装,代理了RealData
 9     boolean isReady = false;    //真实结果是否已经准备好
10 
11     public synchronized void setResultData(RealData realData) {
12         if (isReady) {
13             return;
14         }
15         this.realData = realData;
16         isReady = true;
17         notifyAll();    //realData已经被注入到了futureData中,通知getResult方法
18     }
19 
20     public synchronized String getResult() throws InterruptedException {
21         if (!isReady) {
22             wait();     //数据还未计算好,阻塞等待
23         }
24         return realData.getResult();
25     }
26 }
 1 package com.future;
 2 
 3 /**
 4  * Client主要完成的功能包括:1. 返回一个FutureData;2.开启一个线程用于构造RealData
 5  * Created by yulinfeng on 6/18/17.
 6  */
 7 public class Client {
 8 
 9     public Data request(final String string) {
10         final FutureData futureData = new FutureData();
11 
12         /*计算过程比较慢,单独放到一个线程中去*/
13         new Thread(new Runnable() {
14 
15             public void run() {
16                 RealData realData = new RealData(string);
17                 futureData.setResultData(realData);
18             }
19         }).start();
20 
21         return futureData;  //先返回一个“假”的futureData
22     }
23 }
 1 /**
 2  * 负责调用Client发起请求,并使用返回的数据。
 3  * Created by yulinfeng on 6/18/17.
 4  */
 5 public class Main {
 6     public static void main(String[] args) throws InterruptedException {
 7         Client client = new Client();
 8         System.out.println("准备计算结果");
 9         Data data = client.request("hello");    //立即返回一个“假”的futureData,可以不用阻塞的等待数据返回,转而执行其它任务
10         System.out.println("执行其它任务");
11         Thread.sleep(3000);     //模拟执行其它任务
12         System.out.println("数据的计算结果为:" + data.getResult());
13     }
14 }

  仔细阅读以上程序对Future模式的实现不难发现,Future模式是异步请求和代理模式的结合。当然在JDK中已经为我们实现好了Future模式。

  修改RealData类:

 1 package com.future;
 2 
 3 import java.util.concurrent.Callable;
 4 
 5 /**
 6  * 结果的真实计算过程
 7  * Created by yulinfeng on 6/18/17.
 8  */
 9 public class RealData2 implements Callable<String> {
10     protected String data;
11 
12     public RealData2(String data) {
13         this.data = data;
14     }
15     public String call() throws Exception {
16         try {
17             System.out.println("正在计算结果");
18             Thread.sleep(2000);     //模拟计算结果
19         } catch (InterruptedException e) {
20             e.printStackTrace();
21         }
22         this.data = data + " world";
23         return data;
24     }
25 }

  修改Main测试类:

 1 package com.future;
 2 
 3 import java.util.concurrent.ExecutionException;
 4 import java.util.concurrent.ExecutorService;
 5 import java.util.concurrent.Executors;
 6 import java.util.concurrent.Future;
 7 
 8 /**
 9  * 负责调用Executor的submit,并使用返回的数据。
10  * Created by yulinfeng on 6/18/17.
11  */
12 public class Main2 {
13 
14     public static void main(String[] args) throws InterruptedException, ExecutionException {
15         ExecutorService client = Executors.newSingleThreadExecutor();   //类似Client
16         System.out.println("准备计算结果");
17         Future<String> data = client.submit(new RealData2("hello"));    //类似Client.request
18         System.out.println("执行其它任务");
19         Thread.sleep(3000);
20         System.out.println("数据的计算结果为:" + data.get());
21     }
22 }

  现在回到上文还未解决完的AbstractExecutorService#submit方法。

  类比上面的Client#request方法,在Client#request中先创建一个FutureData实例,而在AbstractExecutorService#submit中则是创建一个FutureTask实例,接着Client#request新创建一个线程用于异步执行任务,并直接返回FutureData,而在AbstractExecutorService#submit中同样也将任务交给了execute方法,并直接返回FutureTask。当然JDK中Future模式的实现更为复杂。

  在《12.ThreadPoolExecutor线程池原理及其execute方法》中我们讲解了execute方法,在ThreadPoolExecutor$Worker#runWorker方法第1145行中是对task任务的调用:

//ThreadPoolExecutor$Worker#runWorker
task.run();

   submit调用execute以执行run方法,实际执行的是FutureTask中的run方法。在FutureTask#run中,可以看到对任务Callable类型的task异步的执行,以及结果的保存。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏老马说编程

(79) 方便的CompletionService / 计算机程序的思维逻辑

上节,我们提到,在异步任务程序中,一种常见的场景是,主线程提交多个异步任务,然后希望有任务完成就处理结果,并且按任务完成顺序逐个处理,对于这种场景,Java并发...

1809
来自专栏小灰灰

Java并发学习之CountDownLatch实现原理及使用姿势

CountDownLatch实现原理及使用姿势 在并发编程的场景中,最常见的一个case是某个任务的执行,需要等到多个线程都执行完毕之后才可以进行,Count...

5.6K10
来自专栏名山丶深处

Hello——Java10新特性,请了解一下

1455
来自专栏炉边夜话

JNI设计实践之路

本文为在 32 位 Windows 平台上实现 Java 本地方法提供了实用的示例、步骤和准则。本文中的示例使用 Sun公司的 Java Development...

1763
来自专栏漏斗社区

Burp Suite API学习思路(二)

在上篇工具| Burp Suite API学习思路文章中,斗哥介绍了BurpSuite扩展开发的一些准备工作与利用IHttpListener接口监听模块接收返回...

1082
来自专栏老马说编程

(80) 定时任务的那些坑 / 计算机程序的思维逻辑

本节探讨定时任务,定时任务的应用场景是非常多的,比如: 闹钟程序或任务提醒,指定时间叫床或在指定日期提醒还信用卡 监控系统,每隔一段时间采集下系统数据,对异...

2929
来自专栏逸鹏说道

C#异步调用的方法

最经公司工作需要调用一个外部的webservice,同时要将传出的数据进行保存,以自己以前的习惯,就打算逐步操作,失败啊,完全没考虑过用户体验效果,在同事指点下...

3596
来自专栏CVer

糟了!Python3.7.0 来了

美国时间6月27日晚8点,Python 3.7.0 经过多轮测试,终于发布了正式版,增强了多处特性功能,同时 3.6 也更新到 3.6.6 稳定版本。

1814
来自专栏dotnet & java

WCF 入门(20)

今天第20集了。这个视频系列里面有6集和异常相关,这集是最后一集。前面几集讲了服务端遇到普通的 .net exception时候,要转换城Soap Fault,...

633
来自专栏Java帮帮-微信公众号-技术文章全总结

Java并发学习4【面试+工作】

Fork/Join框架是Java7提供了的一个用于并行执行任务的框架, 是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。

1432

扫码关注云+社区

领取腾讯云代金券