Future 模式简介

简介

Future 模式是多线程开发中的一种常见设计模式，它的核心思想是异步调用。

比如我们在网上购物，付款后就会产生一个订单，之后你该干嘛干嘛，快递小哥会上门送货，而不必像在超市结账那样，付款后要等着收银员打出小票再帮你打包商品，这个时间你只能站那等着。

总的来说，Future 模式无法立即给出你想要的结果，但它会给你一个契约，之后你可以随时通过这个契约来获取你想要的结果。

例子

下边举个简单的例子：

例子中，Data 接口有两个实现类，RealData 表示真实的数据也就是最终想要的，FutureData 表示一个契约，通过这个 FutureData 可以获得 RealData 的真实数据。

FutureData：

package com.zhengbin.springboot.future;

/**
 * Created by zhengbin on 2017/11/14
 */
public class FutureData implements Data {
    private RealData realData = null;
    private boolean isReady = false;

    public synchronized void setRealData(RealData realData) {
        if (isReady) {
            return;
        }
        this.realData = realData;
        isReady = true;
        notifyAll();
    }

    @Override
    public synchronized String getResult() {
        while (!isReady) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        return realData.getResult();
    }
}

FutureData 相当于 RealData 的代理（契约），封装了获取 RealData 等待的过程。

调用 getRealData 方法时，如果数据还没有准备好，线程就会等待（阻塞），当执行 setRealData 后，将会唤醒所有等待（阻塞）中的线程，这时才能获取到数据。

RealData：

package com.zhengbin.springboot.future;

/**
 * Created by zhengbin on 2017/11/14
 */
public class RealData {
    private final String result;

    public RealData(String param) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0;i < 10;i++) {
            sb.append(param);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
            }
        }
        result = sb.toString();
    }

    public String getResult() {
        return result;
    }
}

RealData 的构造函数，模拟了一个数据构成很慢的过程。

Client：

package com.zhengbin.springboot.future;

/**
 * Created by zhengbin on 2017/11/14
 */
public class Client {
    public Data request(final String requestStr) {
        final FutureData futureData = new FutureData();
        new Thread() {
            @Override
            public void run() {
                RealData realData = new RealData(requestStr);
                futureData.setRealData(realData);
            }
        }.start();
        return futureData;
    }
}

Client 就是我们调用的客户端，实现了获取 FutureData，并开启构造 RealData 的线程，该线程单独执行，主线程直接返回，只不过返回的是一个契约也就是 FutureData，真正的数据 RealData 则在另一个单独的线程中缓慢的构造，构造完成后就会通过 FutureData 的 setRealData 将真实数据保存，这样客户端就可以 get 到真实数据了。

FutureTest：

package com.zhengbin.springboot.future;

/**
 * Created by zhengbin on 2017/11/14
 */
public class FutureTest {
    public static void main(String[] args) throws InterruptedException {
        Client client = new Client();
        Data futureData = client.request("zhengbin");
        System.out.println("request done...");
        Thread.sleep(500);
        System.out.println("other done...");
        System.out.println("result : "+futureData.getResult());
    }
}

测试方法通过 Client 发起调用，调用后模拟执行其他的逻辑，耗费 0.5 秒，之后需要用到 Data 的数据了，但构造真实数据的时间需要 3 秒，此时主线程就会阻塞在这里，等待真实数据的构造完成。

这种方式就给了主线程去执行其他任务的时间，节省了 0.5 秒的时间，可以用来去做别的事情。

参考资料

[1] 实战 Java 高并发程序设计 5.5