并发模型之Future设计模式

一、Futrue模式

客户端发送一个长时间的请求，服务端不需等待该数据处理完成便立即返回一个伪造的代理数据（相当于商品订单，不是商品本身），用户也无需等待，先去执行其他的若干操作后，再去调用服务器已经完成组装的真实数据。

该模型充分利用了等待的时间片段。简单来说就是，如果线程A要等待线程B的结果，那么线程A没必要等待B，直到B有结果，可以先拿到一个未来的Future，等B有结果是再取真实的结果。

在多线程中经常举的一个例子就是：网络图片的下载，刚开始是通过模糊的图片来代替最后的图片，等下载图片的线程下载完图片后在替换。而在这个过程中可以做一些其他的事情。

二、Future模式的代码实现

1、创建公共数据接口

package com.ietree.basicskill.mutilthread.designpattern;

/**
 * Created by Root on 5/12/2017.
 */
public interface Data {

    String getRequest();

}

2、创建FutureData对象，当有程序想要获取RealData的时候，程序会被阻塞，等到RealData被注入才会使用getReal()方法

package com.ietree.basicskill.mutilthread.designpattern;

/**
 * Created by Root on 5/12/2017.
 */
public class FutureData implements Data {

    private RealData realData;

    private boolean isReady = false;

    public synchronized void setRealData(RealData realData) {
        // 如果已经装载完毕了，就直接返回
        if (isReady) {
            return;
        }
        // 如果没装载，进行装载真实对象
        this.realData = realData;
        isReady = true;
        // 进行通知
        notify();
    }

    @Override
    public synchronized String getRequest() {
        // 如果没装载好，程序就一直处于阻塞状态
        while (!isReady) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 装载好了直接获取数据即可
        return this.realData.getRequest();
    }
}

3、真实数据RealData类

package com.ietree.basicskill.mutilthread.designpattern;

/**
 * Created by Root on 5/12/2017.
 */
public class RealData implements Data {

    private String result;

    public RealData(String queryStr) {
        System.out.println("根据" + queryStr + "进行查询，这是一个很耗时间的操作......");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("操作完毕，获取结果");
        result = "查询结果";
    }

    @Override
    public String getRequest() {
        return result;
    }
}

4、客户端代理类

package com.ietree.basicskill.mutilthread.designpattern;

/**
 * Created by Root on 5/12/2017.
 */
public class FutureClient {

    public Data request(final String queryStr) {
        //1 我想要一个代理对象（Data接口的实现类）先返回给发送请求的客户端，告诉他请求已经接收到，可以做其他的事情
        final FutureData futureData = new FutureData();
        //2 启动一个新的线程，去加载真实的数据，传递给这个代理对象
        new Thread(new Runnable() {
            @Override
            public void run() {
                //3 这个新的线程可以去慢慢的加载真实对象，然后传递给代理对象
                RealData realData = new RealData(queryStr);
                futureData.setRealData(realData);
            }
        }).start();

        return futureData;
    }

}

5、测试调用

package com.ietree.basicskill.mutilthread.designpattern;

/**
 * Created by Root on 5/12/2017.
 */
public class FutureTest {

    public static void main(String[] args) {
        FutureClient fc = new FutureClient();
        Data data = fc.request("请求参数");
        System.out.println("请求发送成功！");

        try {
            //处理其他业务
            //这个过程中，真实数据RealData组装完成，重复利用等待时间
            System.out.println("做其它的事情......");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 获取真实数据
        String result = data.getRequest();
        System.out.println(result);
    }

}

程序运行结果：

请求发送成功！
做其它的事情......
根据请求参数进行查询，这是一个很耗时间的操作......
操作完毕，获取结果
查询结果

第二种写法（没有实际运用过）：

package com.ietree.basicskill.mutilthread.designpattern;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * Created by Root on 5/12/2017.
 */
public class FutureTest2 {

    private static class Task implements Callable<String> {
        @Override
        public String call() throws Exception {
            // 模拟真实事务的处理过程，这个过程是非常耗时的。
            Thread.sleep(5000);
            return "call return ";
        }
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        
        List<Future<String>> futures = new ArrayList<Future<String>>();
        ExecutorService executorService = Executors.newCachedThreadPool();

        System.out.println("已经提交资源申请");
        for (int i = 0; i < 10; i++) {
            futures.add(executorService.submit(new Task()));
        }

        for (Future<String> future : futures) {
            // 判断资源是不是已经准备完毕，准备完毕直接获取。
            if (!future.isDone()) {
                System.out.println("资源还没有准备好");
            }
            System.out.println(future.get());
        }
        executorService.shutdown();
    }
}