作用和举例
future类的作用就是为了调用其他线程完成好后的结果,再返回到当前线程中,如上图举例:
小王自己是主线程,叫外卖等于使用future类,叫好外卖后小王就接着干自己的事去了,当外卖到了的时候,future.get获取,继续做接下来的事情
但要注意的是当还没获取外卖的时候,主线程中用餐这一步是卡住的
另一个实际项目中的例子:
在进行传统的 RPC(远程调用)时,同步调用 RPC 是一段耗时的过程。当客户端发出 RPC请求,服务端完成请求处理需要很长的一段时间才会返回,这个过程中客户端一直在等待,直到 数据返回随后再进行其他任务的处理。现有一个 Client 同步对三个 Server 分别进行一次 RPC调用。
假设一次远程调用的时间为 500ms,则一个 Client 同步对三个 Server 分别进行一次 RPC 调 用的总时间,需要耗费 1500ms。如果节省这个总时间呢,可以使用 Future 模式对其进行改造,将同步的 RPC 调用改为异步并发的 RPC 调用,一个 Client 异步并发对三个 Server 分别进行一次 RPC 调用
JDK中的Future实现
结构如下
future接口定义的方法:
- cancel():如果等太久,你可以直接取消这个任务
- isCancelled():任务是不是已经取消了
- isDone():任务是不是已经完成了
- get():有2个get()方法,不带参数的表示无穷等待,或者你可以只等待给定时间
使用:
//异步操作 可以用一个线程池
ExecutorService executor = Executors.newFixedThreadPool(1);
//执行FutureTask,相当于上例中的 client.request("name") 发送请求
//在这里开启线程进行RealData的call()执行
Future<String> future = executor.submit(new RealData("name"));
System.out.println("请求完毕,数据准备中");
try {
//这里依然可以做额外的数据操作,这里使用sleep代替其他业务逻辑的处理
Thread.sleep(2000);
} catch (InterruptedException e) {
}
//如果此时call()方法没有执行完成,则依然会等待
System.out.println("数据 = " + future.get());
executor.submit()里传线程类
走这里看源码
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
// 根据Callable对象,创建一个RunnableFuture,这里其实就是FutureTask
RunnableFuture<T> ftask = newTaskFor(task);
//将ftask推送到线程池
//在新线程中执行的,就是run()方法,在下面的代码中有给出
execute(ftask);
//返回这个Future,将来通过这个Future就可以得到执行的结果
return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
RunnableFuture其实就是FutureTask
FutureTask作为一个线程单独执行时,会将结果保存到outcome中,并设置任务的状态,下面是FutureTask的run()方法:
Future类最关键的get实现
FutureTask源码,关键在于awaitDone()
方法里有park()
阻塞了线程,成功后返回outcome
outcome:保存的就是最终的计算结果,get/set里都有它
Future模式的高阶版本—— CompletableFuture
Future模式虽然好用,但也有一个问题,那就是将任务提交给线程后,调用线程并不知道这个任务什么时候执行完,如果执行调用get()方法或者isDone()方法判断,可能会进行不必要的等待,那么系统的吞吐量很难提高。
CompletableFuture可以理解为Future模式的升级版本,它最大的作用是提供了一个回调机制,可以在任务完成后,自动回调一些后续的处理,这样,整个程序可以把“结果等待”完全给移除了。
例子:
它可以在Future执行成功后,自动回调进行下一步的操作,因此整个程序不会有任何阻塞的地方(也就是说你不用去到处等待Future的执行,而是让Future执行成功后,自动来告诉你)。
CompletableFuture之所有会有那么神奇的功能,完全得益于AsyncSupply类(由上述代码中的supplyAsync()方法创建)
作为Runnable,看他run的方法
d.completeValue(f.get())
就是你要执行的异步方法,结果会被保存下来,放到d.result字段中
d.postComplete()
会调用后续一系列操作,在这个后续处理中,就会调用thenAccept()中的消费者,相当于Future完成后的通知
代码如下:
final void postComplete() {
//省略部分代码,重点在tryFire()里
//在tryFire()里,真正触发了后续的调用,也就是thenAccept()中的部分
f = (d = h.tryFire(NESTED)) == null ? this : d;
}
}
}
实现自己的Future模式
还是用敖丙的例子,主要实现类如下:
先定义接口
public interface Data {
public String getResult ();
}
实现自己的future类:
public class FutureData implements Data {
// 内部需要维护RealData
protected RealData realdata = null;
protected boolean isReady = false;
public synchronized void setRealData(RealData realdata) {
if (isReady) {
return;
}
this.realdata = realdata;
isReady = true;
//RealData已经被注入,通知getResult()
notifyAll();
}
//会等待RealData构造完成
public synchronized String getResult() {
while (!isReady) {
try {
//一直等待,直到RealData被注入
wait();
} catch (InterruptedException e) {
}
}
//真正需要的数据从RealData获取
return realdata.result;
}
}
关键在于isReady
这个布尔,while (!isReady)
作为自旋锁,想要获取这个future的结果,他会一直等待,直到RealData被注入
RealData类:
public class RealData implements Data {
protected final String result;
public RealData(String para) {
StringBuffer sb=new StringBuffer();
//假设这里很慢很慢,构造RealData不是一个容易的事
result =sb.toString();
}
public String getResult() {
return result;
}
}
Client类,目的是将RealData注入到FutureData
public class Client {
//这是一个异步方法,返回的Data接口是一个Future
public Data request(final String queryStr) {
final FutureData future = new FutureData();
new Thread() {
public void run() {
// RealData的构建很慢,所以在单独的线程中进行
RealData realdata = new RealData(queryStr);
//setRealData()的时候会notify()等待在这个future上的对象
future.setRealData(realdata);
}
}.start();
// FutureData会被立即返回,不会等待RealData被构造完
return future;
}
}
mian方法通过data.getResult()
拿数据
public static void main(String[] args) {
Client client = new Client();
//这里会立即返回,因为得到的是FutureData而不是RealData
Data data = client.request("name");
System.out.println("请求完毕");
try {
//这里可以用一个sleep代替了对其他业务逻辑的处理
//在处理这些业务逻辑的过程中,RealData被创建,从而充分利用了等待时间
Thread.sleep(2000);
} catch (InterruptedException e) {
}
//使用真实的数据,如果到这里数据还没有准备好,getResult()会等待数据准备完,再返回
System.out.println("数据 = " + data.getResult());
}
自己实现就拿wait简单处理,future类使用park阻塞
总结
Future 模式的核心思想是异步调用,有点类似于异步的 Ajax 请求。当调用某个耗时方法时, 可以不急于立刻获取结果,可以让被调用者立刻返回一个契约(或异步任务), 并且将耗时的方法放到另外线程执行,后续凭契约再去获取异步执行的结果。
在具体的实现上,Future 模式和异步回调模式既有区别,又有联系。Java 的 Future 模式实现,没有实现异步回调模式,仍然需要主动去获取耗时任务的结果;而 Java 8 中的 CompletableFuture,实现了异步回调模式。
参考:
JAVA Future类详解
更详细的可以看这一遍
Future模式与异步回调模式