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();
}
}
}