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模式。

package com.future;

/**
 * 数据结果
 * Created by yulinfeng on 6/18/17.
 */
public interface Data {
    String getResult() throws InterruptedException;
}

package com.future;

/**
 * 结果的真实计算过程
 * Created by yulinfeng on 6/18/17.
 */
public class RealData implements Data {
    protected String data;

    public RealData(String data) {
        try {
            System.out.println("正在计算结果");
            Thread.sleep(3000);     //模拟计算
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.data = data + “ world”;
    }

    public String getResult() throws InterruptedException {
        return data;
    }
}

package com.future;

/**
 * 真实结果RealData的代理
 * Created by yulinfeng on 6/18/17.
 */
public class FutureData implements Data {
    RealData realData = null;   //对RealData的封装，代理了RealData
    boolean isReady = false;    //真实结果是否已经准备好

    public synchronized void setResultData(RealData realData) {
        if (isReady) {
            return;
        }
        this.realData = realData;
        isReady = true;
        notifyAll();    //realData已经被注入到了futureData中，通知getResult方法
    }

    public synchronized String getResult() throws InterruptedException {
        if (!isReady) {
            wait();     //数据还未计算好，阻塞等待
        }
        return realData.getResult();
    }
}

package com.future;

/**
 * Client主要完成的功能包括：1. 返回一个FutureData；2.开启一个线程用于构造RealData
 * Created by yulinfeng on 6/18/17.
 */
public class Client {

    public Data request(final String string) {
        final FutureData futureData = new FutureData();

        /*计算过程比较慢，单独放到一个线程中去*/
        new Thread(new Runnable() {

            public void run() {
                RealData realData = new RealData(string);
                futureData.setResultData(realData);
            }
        }).start();

        return futureData;  //先返回一个“假”的futureData
    }
}

/**
 * 负责调用Client发起请求，并使用返回的数据。
 * Created by yulinfeng on 6/18/17.
 */
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Client client = new Client();
        System.out.println("准备计算结果");
        Data data = client.request("hello");    //立即返回一个“假”的futureData，可以不用阻塞的等待数据返回，转而执行其它任务
        System.out.println("执行其它任务");
        Thread.sleep(3000);     //模拟执行其它任务
        System.out.println("数据的计算结果为：" + data.getResult());
    }
}

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

　　修改RealData类：

package com.future;

import java.util.concurrent.Callable;

/**
 * 结果的真实计算过程
 * Created by yulinfeng on 6/18/17.
 */
public class RealData2 implements Callable<String> {
    protected String data;

    public RealData2(String data) {
        this.data = data;
    }
    public String call() throws Exception {
        try {
            System.out.println("正在计算结果");
            Thread.sleep(2000);     //模拟计算结果
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.data = data + " world";
        return data;
    }
}

　　修改Main测试类：

package com.future;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 负责调用Executor的submit，并使用返回的数据。
 * Created by yulinfeng on 6/18/17.
 */
public class Main2 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService client = Executors.newSingleThreadExecutor();   //类似Client
        System.out.println("准备计算结果");
        Future<String> data = client.submit(new RealData2("hello"));    //类似Client.request
        System.out.println("执行其它任务");
        Thread.sleep(3000);
        System.out.println("数据的计算结果为：" + data.get());
    }
}

　　现在回到上文还未解决完的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异步的执行，以及结果的保存。