Java 多线程的设计模式之 Future

Future 设计模式核心原理图：

client端通过 FutureData 发送一个执行耗时操作的请求，FutureData 则直接返回一个回调接口的引用（Data 接口，用于返回获取到的真正结果），然后在 FutureData 内部再另起一个线程去执行真正的耗时操作。当 client 端 执行了获取结果的方法时，如果执行完成，则返回结果。如果还在执行中，则会进入线程等待状态，一直等到执行完成进行线程唤醒之后才能拿到结果。

这个设计模式在 Java JDK 中已经被实现了，这里先看一下自测代码，从最里层开始看：

自测 Future 模式实现

• RealData 实现类

public class RealData {

    private String data;

    public RealData(String data) throws InterruptedException {
        System.out.println("模拟数据加载中。。。");
        TimeUnit.SECONDS.sleep(5);
        this.data = data;
    }

    public String getResult() {
        return data + " - real data";
    }
}

上面流程图中标注的 RealData 也要实现 Data 接口，这里自己实现的话，其实也是可以省略的，自己写一个获取方法，效果也是一样的。这里模拟的是执行耗时操作。

• FutureData 实现类

public class FutureData implements Data {

    private boolean isReady;// 是否准备好了。 也就是耗时操作是否执行完成了。
    private RealData data;// 真实数据操作对象

    public synchronized void setRequest(RealData data) {
        if (isReady) {
            return;
        }
        this.data = data;
        isReady = true;
        notify();
    }

    @Override
    public synchronized String getResult() throws InterruptedException {
        if (!isReady) {
            System.out.println("等待数据返回中。。。");
            wait();
        }
        return data.getResult();
    }
}

这里说一下，因为 RealData 的耗时操作直接在构造方法中写的，所以，当进入 setRequest 方法的时候，说明 RealData 已经实例化好了，也就是耗时操作已经执行完成了。这里 FutureData 也就是 RealData 的一个代理，包装着 RealData 的耗时操作过程。

wait() 和 notify() 方法 一定要配合 synchronize 关键字使用。

• Client 端实现

public class Client {

    public Data setRequest(String requestString) {
        FutureData data = new FutureData();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("client run : " + System.currentTimeMillis());
                    data.setRequest(new RealData(requestString));// 当 RealData 的构造方法执行完成之后，才会进入到 setRequest的方法中。
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        return data;
    }
}

• 调用代码

public class Main {
    /**
     * Futrue 设计模式，
     * client端 发送某个耗时请求 - >  FutrueData 代理对象 先返回一个 假对象，然后其内部开启线程进行真实请求操作 -- >  RealData 真实处理对象，处理结束之后，回调数据给 代理对象，代理对象再进行通知 client端
     */

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Client client = new Client();
        Data data = client.setRequest("this is test");
        System.out.println("main ： " + System.currentTimeMillis());
        System.out.println(data.getResult()); // 会进入线程等待状态。

    }
}

JDK 内部 Future 实现

上面也说了，这个设计模式 JDK 内部是已经实现了这个机制。 FutureTask 作为我们的代理类，它实现了 Runnable 接口，本身就作为一个独立的线程执行，但是它没有start 方法，必须配合线程池使用。因为 FutureTask 的传入对象是 Callable（接口） 类型，所以，我们的 RealData 类也需要实现 Callable 接口。真实数据最终会通过 Callable 接口的 call() 方法传递给 FutureTask 。

• 实现代码：

public class RealData_1 implements Callable<String> {

    private String data;

    public RealData_1(String data) {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("real data 1");
        this.data = data;
    }

    @Override
    public String call() throws Exception {
        System.out.println("real data 1 call()");
        return data;
    }
}

• 调用方式：

 public static void main(String[] args) throws InterruptedException, ExecutionException {
//        Client client = new Client();
//        Data data = client.setRequest("this is test");
//        System.out.println("main ： " + System.currentTimeMillis());
//        System.out.println(data.getResult());

        /**
         * Java jdk 内置 FutureTask 是一个线程类，必须使用配合线程池调用。
         */
        FutureTask futureTask = new FutureTask(new RealData_1("this is test jdk future"));
        ExecutorService exe = Executors.newFixedThreadPool(1);

        exe.submit(futureTask);

        System.out.println(futureTask.get());

    }

最后说一下线程池的 submit 方法和 execute 方法的区别：

• submit 可以传入实现 Callable接口的实例对象。
• submit 方法有返回值。