Java程序性能优化 读书笔记（十）并行设计模式：Future模式

转载：Java多线程编程中Future模式的详解<转>

参考：葛一鸣，Java程序性能优化．清华大学出版社．

随着多核时代的到来，CPU的并行能力有了很大的提升。在这种背景下，传统的串行程序已经无法发挥CPU的最大潜能，造成系统资源的浪费。而并行软件开发技术恰好可以在这方面将CPU性能发挥到极致。

Java对多线程的支持为多核计算提供了强有力的保障。首先，Java中提供了Thread对象和Runnable接口用于创建进程内的线程。其次，为了优化并行程序性能，JDK还提供了java.util.concurrent并发包，内置各种多线程性能优化工具和组件，如线程池、各种并发数据结构等。除此之外，为确保多线程间能相互协作，JDK还提供了各种同步工具。

Java多线程编程中，常用的多线程设计模式包括：Future模式、Master-Worker模式、Guarded Suspeionsion模式、不变模式和生产者-消费者模式等。这篇文章主要讲述Future模式。

一、Future模式的核心

Future模式的核心在于：去除了主函数的等待时间，并使得原本需要等待的时间段可以 用于处理其他业务逻辑。Future模式有点类似于商品订单。在网上购物时，提交订单后，在收货的这段时间里无需一直在家里等候，可以先干别的事情。类推到程序设计中时，当提交请求时，期望得到答复时，如果这个答复可能很慢。传统的时一直等待到这个答复收到时再去做别的事情，但如果利用Future设计模式就 无需等待答复的到来，在等待答复的过程中可以干其他事情。

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

二、Future模式的实现

实现中对于客户端和服务器都需要进行设计，首先客户端向服务器请求RealSubject，但是这个资源的创建是非常耗时的，怎么办呢？这种情况下，首先返回Client一个FutureSubject,以满足客户端的需求，于此同时呢，Future会通过另外一个Thread去构造一个真正的资源，资源准备完毕之后，在给future一个通知。如果客户端急于获取这个真正的资源，那么就会阻塞客户端的其他所有线程，等待资源准备完毕。

Client的实现

Client主要完成的功能包括：1. 返回一个 FutureData；2.开启一个线程用于构造 RealData。

public class Client {
    public Data request(final String string) {
        final FutureData futureData = new FutureData();
         
        new Thread(new Runnable() {
            @Override
            public void run() {
                //RealData的构建很慢，所以放在单独的线程中运行
                RealData realData = new RealData(string);
                futureData.setRealData(realData);
            }
        }).start();
         
        return futureData; //先直接返回FutureData
    }
}

Data的实现

无论是FutureData还是RealData都实现该接口。

public interface Data {
    String getResult() throws InterruptedException;
}

FutureData的实现

FutureData是Future模式的关键，它实际上是真实数据 RealData的代理，封装了 获取RealData的等待过程。

public class FutureData implements Data {
    RealData realData = null; //FutureData是RealData的封装
    boolean isReady = false;  //是否已经准备好
     
    public synchronized void setRealData(RealData realData) {
        if(isReady)
            return;
        this.realData = realData;
        isReady = true;
        notifyAll(); //RealData已经被注入到FutureData中了，通知getResult()方法
    }
 
    @Override
    public synchronized String getResult() throws InterruptedException {
        if(!isReady) {
            wait(); //一直等到RealData注入到FutureData中
        }
        return realData.getResult(); 
    }
}

RealData的实现

RealData是最终需要使用的数据，它的构造函数很慢。

public class RealData implements Data {
    protected String data;
 
    public RealData(String data) {
        //利用sleep方法来表示RealData构造过程是非常缓慢的
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.data = data;
    }
 
    @Override
    public String getResult() {
        return data;
    }
}

测试运行

主函数主要负责调用Client发起请求，并使用返回的数据。

public class Application {
    public static void main(String[] args) throws InterruptedException {
        Client client = new Client();
        //这里会立即返回，因为获取的是FutureData，而非RealData
        Data data = client.request("name");
        //这里可以用一个sleep代替对其他业务逻辑的处理
        //在处理这些业务逻辑过程中，RealData也正在创建，从而充分了利用等待时间
        Thread.sleep(2000);
        //使用真实数据
        System.out.println("数据="+data.getResult());
    }
}

三、Future模式的JDK内置实现

由于Future是非常常用的多线程设计模式，因此在JDK中内置了Future模式的实现。这些类在 java.util.concurrent包 里面。其中最为重要的是 FutureTask类，它实现了 Runnable接口，作为单独的线程运行。在其run()方法中，通过Sync内部类调用 Callable接口，并维护Callable接口的 返回对象。当使用FutureTask.get()方法时，将返回Callable接口的返回对象。 同样，针对上述的实例，如果使用JDK自带的实现，则需要作如下调整。

首先， Data接口和FutureData就不需要了，JDK帮我们实现了。

其次， RealData改为这样：

import java.util.concurrent.Callable;
 
public class RealData implements Callable {
    protected String data;
 
    public RealData(String data) {
        this.data = data;
    }
 
    @Override
    public String call() throws Exception {
        //利用sleep方法来表示真是业务是非常缓慢的
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return data;
    }
}

最后，在测试运行时，这样调用：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
 
public class Application {
    public static void main(String[] args) throws Exception {
        FutureTask futureTask = new FutureTask(new RealData("name"));
        ExecutorService executor = Executors.newFixedThreadPool(1); //使用线程池
        //执行FutureTask，相当于上例中的client.request("name")发送请求
        executor.submit(futureTask);
        //这里可以用一个sleep代替对其他业务逻辑的处理
        //在处理这些业务逻辑过程中，RealData也正在创建，从而充分了利用等待时间
        Thread.sleep(2000);
        //使用真实数据
        //如果call()没有执行完成依然会等待
        System.out.println("数据=" + futureTask.get());
    }
}