[面试]future模式

Future模式

什么是future模式?

传统单线程环境下，调用函数是同步的，必须等待程序返回结果后，才可进行其他处理。 Futrue模式下，调用方式改为异步。

Futrue模式的核心在于：充分利用主函数中的等待时间，利用等待时间处理其他任务，充分利用计算机资源。

简单描述一下future模式的实现

future模式有两种数据, 一种是真实数据RealData, 里面就是业务中想要得到的目标数据. 另一种是虚拟数据FutureData, 它是在使用future模式时立即返回的一个对象. 

调用方会首先拿到一个FutureData, 然后调用方就认为自己拿到该数据了, 没有进行阻塞, 继续去执行下面的逻辑处理. 如果真实数据准备好了, 就会把自己的引用赋给之前的那个FutureData, 并且置一个标记, 表示这个FutureData里面包含一个RealData, 拿到了想要的数据, 可以使用.

详细分的话, 会有下面这几种情况(假设RealData需要2秒才能创建好):

1. 调用方发送了自己需要RealData的请求的后, 会立即拿到一个FutureData, 但是根本就不着急使用, 所以, 第2秒的时候RealData创建完成后, 就会被绑定到对应的FutureData里. 假设第6秒调用方才开始使用RealData, 他会发现FutureData已经准保好了他想要的数据, 于是开心地使用就ok了.

2. 调用方发送了自己需要RealData的请求的后, 会立即拿到一个FutureData, 但是很着急使用, 因为接下来的处理过程依赖于RealData的内容. 于是在第0.5秒的时候, 调用方就想要获取RealData. 但是这个时候RealData并没有准备好, 此时的FutureData是一个空壳而已. 所以就在这里进行wait(或者忙等待). 直到RealData准备好,也就是再过1.5秒, 线程才会唤醒(或者打破忙等待).

请用代码实现一下Future模式

FutureData和RealData的统一抽象接口, Data类如下:

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

RealData类

public class RealData implements Data {
    private int data;

    public RealData(int num) {
        //这里用sleep来模拟构造一个复杂对象的场景
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        this.data = num * 10;
    }

    @Override
    public int getResult() {
        return data;
    }
}

FutureData类

public class FutureData implements Data {
    // 真实数据RealData的引用.
    private RealData realData = null;

    public synchronized void setRealData(RealData realData) {
        // 如果this.realData不是空, 说明已经准备好了, 直接return
        if (this.realData != null)
            return;
        this.realData = realData;
        notifyAll();
    }

    @Override
    public synchronized int getResult() throws InterruptedException {
        // 如果this.realData是null, 说明数据还没准备好, 应该等待
        if (this.realData == null) {
            wait();
        }
        return realData.getResult();
    }
}

Client类

直接创建一个FutureData, 然后直接返回这个FutureData. 同事开辟一个线程来创建RealData, 并且在RealData创建完后绑定在FutureData中.

public class Client {
    public Data request(final int num) {
        // 当有请求的时候, 先创建一个虚拟对象.
        final FutureData futureData = new FutureData();

        // 然后开启一个新线程去创建RealData, 当RealData创建完成后, 绑定带FutureData里.
        new Thread(() -> {
            RealData realData = new RealData(num);
            futureData.setRealData(realData);
        }).start();

        // 不管RealData有没有创建完成, 都会直接返回这个FutureData.
        return futureData;
    }
}

Main

调用这个Future模型.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Client client = new Client();

        // 调用了之后会立即返回一个FutureData, 这个data就是FutureData
        Data data = client.request(4);

        // 用sleep来模拟主线程正在处理其他事情
        Thread.sleep(0);

        // getResult来获取真实数据
        //     |- 如果这时候真实数据没准备好, 那么就wait, 等待notify, 然后获取到真实数据
        //     |- 如果这时候真实数据准备好了, 那么就可以直接获取到了
        System.out.println("数据=" + data.getResult());
    }
}

 在RealData处进行了*10 的处理, 所以request(4), 最终会返回40.

使用过JDK自带的Future模式吗?

使用过, 例子如下:

定义一个RealData类

import java.util.concurrent.Callable;

public class RealData implements Callable<Integer> {
    private int data;

    public RealData(int data) {
        this.data = data * 10;
    }

    @Override
    public Integer call() {
        //利用sleep方法来表示真是业务是非常缓慢的
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return data;
    }
}

 Main

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class Main {
    public static void main(String[] args) throws Exception {
        //线程池
        ExecutorService executor = Executors.newFixedThreadPool(1); //使用线程池

        // 之前自己实现的future模式中的 Data data = client.request(4) 这句相当于下面这两行代码
        //1. Data data
        FutureTask<Integer> futureTask = new FutureTask<>(new RealData(4));
        //2. 这里相当于 client.request(4);
        executor.submit(futureTask);

        //这里可以用一个sleep代替对其他业务逻辑的处理
        Thread.sleep(0);

        // 获取真实数据
        try {
            System.out.println("数据=" + futureTask.get());
        }finally {
            executor.shutdown();
        }
    }
}