（十四）Java中的Future模式

「爱情、让人受尽委屈。」 2022-01-22 15:07 131阅读 0赞

***jdk1.7.0\_79 ***

本文实际上是对上文[《ThreadPoolExecutor线程池之submit方法》][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它代表一个异步计算的结果。

![630246-20170618221359946-1745255817.png][]

上面就代表了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模式的实现更为复杂。

在[《ThreadPoolExecutor线程池原理及其execute方法》][ThreadPoolExecutor_execute]中我们讲解了execute方法，在ThreadPoolExecutor$Worker\#runWorker方法第1145行中是对task任务的调用：

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

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

[ThreadPoolExecutor_submit]: http://www.cnblogs.com/yulinfeng/p/7039979.html
[630246-20170618221359946-1745255817.png]: /images/20220122/f8217f0241b0492fb15a4f9e17d7fb5d.png
[ThreadPoolExecutor_execute]: http://www.cnblogs.com/yulinfeng/p/7021293.html