Future模式

Java多线程中，Callable/Future接口是一个非常重要的知识点，我们都知道无论继承Thread类，还是实现Runnable接口，在线程任务执行结束后，都无法获取执行结果，所以Java中提供了Callable、Future接口，Callable的call方法用来执行任务，产出结果，Future的get方法用来获取线程执行的结果。它们的底层使用的其实是Future模式。比如，现在主线程发送一个请求想要获取数据，但是数据组装很耗时，那么使用Future模式就可以让主线程在该段时间里不必阻塞等待，而可以去处理其它业务逻辑。

Future模式的核心：除去主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑。下面就通过手写一个代码简单实现Future模式。

首先定义一个公共接口Data

public interface Data {
    public abstract String getResult();
}

 FutureData类实现Data接口

/**
 * @author Administrator
 * @date 2019/3/2
 */
public class FutureData implements Data {
    //isReady表示realData对象是否组装好了
    public volatile static boolean isReady=false;
    private RealData realData;
    public synchronized void setRealData(RealData realData){
        if(isReady){//为true表示已经组装好realData对象，则直接返回
            return;
        }
        this.realData=realData;
        isReady=true;
        notify();
    }
    @Override
    public synchronized String getResult() {
        while(!isReady){
            try {
                wait();
            } catch (InterruptedException e) {

            }
        }
        return realData.getResult();
    }
}

RealData类实现Data接口

/**
 * @author Administrator
 * @date 2019/3/2
 */
public class RealData implements Data{
    private String result;
    public RealData(String name){
        //利用sleep方法表示realData对象组装过程非常缓慢
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if("Tom".equals(name)){
            result="Tom-美国人-30";
        }else{
            result="名字为"+name+"的人的信息不存在";
        }
        System.out.println("ResultData对象构造完成");
    }

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

客户端

/**
 * @author Administrator
 * @date 2019/3/2
 */
public class Client {
    public Data request(String name){
        FutureData futureData=new FutureData();
        new Thread(new Runnable() {
            @Override
            public void run() {
                //执行下面这句，进行realData对象的组装，过程很慢
                //因为放在单独的子线程中运行，所以子线程会被阻塞
                //主线程没影响，不会被阻塞
                RealData realData=new RealData(name);
                futureData.setRealData(realData);
            }
        }).start();
        return futureData;
    }
}

测试

public class Test {
    public static void main(String[] args){
        Client client=new Client();
        final Data request = client.request("Tom");
        System.out.println("main-----请求发送成功！");
        System.out.println("main-----主线程无需等待，继续执行其它任务...");
        final String result = request.getResult();//在该行之前主线程没有阻塞，该行会引起主线程阻塞
        System.out.println("main-----结果为："+result);
    }
}

结果

main-----请求发送成功！
main-----主线程无需等待，继续执行其它任务...
ResultData对象构造完成
main-----结果为：Tom-美国人-30

Process finished with exit code 0

简单解释一下：Test类中使用client.request("Tom")，到客户端client类里面开启一个子线程，调用new RealData(name)方法进行realData对象的组装，由于realData对象的组装非常耗时，所以子线程阻塞，此时主线程没影响，返回一个futureData对象。此时主线程不用等待，继续执行其他任务，当其它任务执行完后，执行request.getResult()方法。假如此时realData对象还没有组装完，则主线程执行到FutureData里面的getResult()方法时，会因为isReady为false而执行wait()方法，从而主线程被阻塞，直到realData对象组装完成，子线程执行notify()方法，isReady为true，主线程被唤起，调用realData对象的getResult()方法，返回值"Tom-美国人-30"到Test类里面。