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;}@Overridepublic int getResult() {return data;}
}
FutureData类
public class FutureData implements Data {// 真实数据RealData的引用.private RealData realData = null;public synchronized void setRealData(RealData realData) {// 如果this.realData不是空, 说明已经准备好了, 直接returnif (this.realData != null)return;this.realData = realData;notifyAll();}@Overridepublic 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就是FutureDataData 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;}@Overridepublic 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 dataFutureTask<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();}}
}
