Java并行程序设计模式——Future模式

标签: Future模式

问题引出

现在我们想要炒一道菜,但是我们没有厨具和菜,现在我们从网上订购了一套厨具,但在厨具送来的期间,我们不必一直等到厨具到来,而是可以先去买菜,然后厨具到了之后直接开始炒菜

这就是Future模式,在程序设计中,当某一段程序提交了一个请求,期望得到一个答复。但非常不幸的是,服务程序对这个请求的处理可能很慢,比如这个请求可能是通过互联网、HTTP或者Web Service等并不太高效的方式调用的。在传统的单线程模式下,调用函数是同步的,也就是说他必须等到服务程序返回结果后,才能进行其他处理而在Future模式下,调用方式改为异步,而原先等待返回的时间段,在主调用函数中,则可用于处理其他事务

传统模式与Future模式流程对比

在这里插入图片描述在这里插入图片描述
可以看出,Future模式中,虽然call本身仍然需要很长一段时间来处理程序。但是,服务程序不等数据处理完成便立即返回客户端一个伪造的数据(相当于商品订单,而不是商品本身)。
实现了Future模式的客户端在拿到这个返回结果后,并不着急对其进行处理,而去调用了其他业务逻辑,充分利用了等待时间。在完成了其他业务逻辑后,最后再使用返回比较慢的Future数据。这样,在整个调用过程中,就不存在无谓的等待,充分利用了所有的时间片段,从而提高系统的响应速度

Future模式的代码实现

在这里插入图片描述

参与者 作用
Main 系统启动,调用Client发送请求,并使用返回数据
Client 返回Data对象,立即返回FutureData,并开启ClientThread线程装配RealData
Data 返回数据的接口
FutureData Future数据,构造很快,但是是一个虚拟数据,需要装配RealData
RealData 真实数据,构造比较缓慢
public class Main {
    public static void main(String[] args) {
        Client client = new Client();
        // 这里会立刻返回,因为得到的是FutureData而不是RealData
        Data data = client.request("name");
        System.out.println("请求完毕");
        try {
            // 这里可以用一个sleep替代对其他业务逻辑的处理
            // 在处理这些业务逻辑的过程中,RealData被创建,从而充分利用了等待时间
            Thread.sleep(1000);
            System.out.println("其他操作");
        } catch (InterruptedException e) {

        }
        // 使用真实数据
        System.out.println("真实数据:" + data.getResult());
    }
}
public class Client {
    public Data request(final String queryStr) {
        final FutureData futureData = new FutureData();
        new Thread() {
            @Override
            public void run() {
                RealData realData = new RealData(queryStr);
                futureData.setRealData(realData);
            }
        }.start();
        return futureData;
    }
}
public interface Data {
    public String getResult();
}
// FutureData是Future模式的关键,它实际上是真实数据RealData的代理,封装了获取RealData的等待过程
public class FutureData implements Data {

    protected RealData realData = null;
    protected boolean isReady = false;

    public synchronized void setRealData(RealData realData) {
        if (isReady) {
            return;
        }
        this.realData = realData;
        this.isReady = true;
        notifyAll();        // RealData已经被注入,通知getResult()
    }

    @Override
    public synchronized String getResult() {    // 会等待RealData构造完成
        while (!isReady) {
            try {
                wait();             // 一直等待,直到RealData注入
            } catch (InterruptedException e) {

            }
        }
        return realData.result;        // 由RealData实现
    }
}
public class RealData implements Data {

    protected final String result;

    public RealData(String para) {
        // RealData构造可能会很慢,需要用户等待很久,这里使用sleep模拟
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 10; i++) {
            sb.append(para + " ");
            try {
                // 这里使用sleep模拟,代替一个很慢的操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }
        }
        result = sb.toString();
    }

    @Override
    public String getResult() {
        return result;
    }
}
// 运行结果
请求完毕
// 等待一秒后
其他操作
//(等待10秒)
真实数据:name name name name name name name name name name 

扩展

由于Future模式的常用性,以至于JDK的并发包中就已经内置了一种Future模式的实现。JDK中的实现是相当复杂的,并提供了更为丰富的线程控制功能,但其中的基本用意和核心概念是完全一致的

在这里插入图片描述使用JDK内置的Future模式

public class RealData implements Callable<String> {
    private String para;

    public RealData(String para) {
        this.para = para;
    }

    @Override
    public String call() throws Exception {
    	// 这里是真实的业务逻辑,其执行可能会很慢
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 10; i++) {
            sb.append(para + " ");
            try {
                // 这里使用sleep模拟,代替一个很慢的操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }
        }
        return sb.toString();
    }
}
// 由于使用了JDK内置的框架,Data接口,FutureData等对象就不再需要了
// 直接通过RealData构造FutureTask,并将其作为单独的线程运行。在提交结果后,执行其他业务逻辑,最后通过FutureTask.get()方法得到RealData的执行结果
public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 构造FutureTask
        FutureTask<String> futureTask = new FutureTask<String>(new RealData("a"));
        ExecutorService executor = Executors.newFixedThreadPool(1);
        // 执行FutureTask,相当于上例中的client.request("a") 发送请求
        // 在这里开启线程进行RealData的call()执行
        executor.submit(futureTask);
        System.out.println("请求完毕");
        try {
            // 这里依然可以做额外的数据操作,这里使用sleep代替其他业务逻辑的处理
            Thread.sleep(1000);
            System.out.println("其他操作");
        } catch (InterruptedException e) {

        }
        // 相当于上例中的data,getResult(),取得call()方法的返回值
        // 如果此时call()方法没有执行完成,则依然会等待
        System.out.println("真实数据:" + futureTask.get());
    }
}
// 结果
请求完毕
// 等待一秒后
其他操作
// 等待一段时间
真实数据:a a a a a a a a a a 
注:
  1. JDK内置的Future模式功能强大,除了基本的功能外,它还可以取消Future任务,或者设定Future任务的超时时间
  2. Future模式的核心在于去除了主函数中的等待时间,并使得原本需要等待的时间段可以用于处理其他业务逻辑,从而充分利用计算机资源
版权声明:本文为qq_44039966原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_44039966/article/details/103324170