Future详解
要深入理解CompletableFuture,就必须先搞懂Future的原理,因为CompletableFuture是在其基础上增加了回调和JDK1.8的操作
一、线程池提交Callable,返回Future,通过future.get,阻塞地获取结果
项目中使用Future,将Callable
ListenableFuture future = listeningExecutorService
.submit(() -> save());
executeFutures.add(future);
future.get();
submit方法,这里的线程池继承了ThreadExecutor,实现了submit方法。在原来的submit上做了增强,能够在线程传递之时,把spanId传给子线程。submit依然是交给父类ThreadExecutor的submit方法执行
@Override
public
提交后,AbstractExecutorService会将Callable通过newTaskFor利用构造函数新建一个FutureTask,由于RunnableFuture继承了Runnable和Future接口,所以excute可以执行ftask。并且可以返回结果
public
构造函数保存callable,将state初始化为NEW,而且还可以兼容Runnable的传入。通过Executors.callable适配器模式,将Runnable适配为Callable
public FutureTask(Callable
提交到线程池之后,什么时候能够执行,就跟线程池的策略有关了,具体跟核心线程数、工作队列、最大线程数、拒绝策略等参数有关。当轮到此任务执行时,会调用FutureTask中的run()方法。
二、FutureTask的结构和状态机
接下来先看下FutureTask的继承体系和数据结构
/** 封装的Callable对象,其call方法用来执行异步任务,其实就是把callable包装在这里,执行call()方法之后,future可以拿到结果,在get()中返回 */
private Callable
状态
private static final int NEW= 0;
private static final int COMPLETING= 1;
private static final int NORMAL= 2;
private static final int EXCEPTIONAL= 3;
private static final int CANCELLED= 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED= 6;
状态的转换如下:
三、future的run方法:当前状态为NEW->调用call()方法->保存异常或者正常执行的结果,并进行状态的流转。保存结果后就可以用finishComplete唤醒阻塞的线程NEW -> COMPLETING -> NORMAL
:这个状态变化表示异步任务的正常结束,其中COMPLETING
是一个瞬间临时的过渡状态,由set
方法设置状态的变化;NEW -> COMPLETING -> EXCEPTIONAL
:这个状态变化表示异步任务执行过程中抛出异常,由setException
方法设置状态的变化;NEW -> CANCELLED
:这个状态变化表示被取消,即调用了cancel(false)
,由cancel
方法来设置状态变化;NEW -> INTERRUPTING -> INTERRUPTED
:这个状态变化表示被中断,即调用了cancel(true)
,由cancel
方法来设置状态变化。
然后我们就可以看看run()方法执行过程了
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
//当前状态不是NEW或者将当前线程设置为runner对象失败时返回,说明有其他线程执行过了。
return;
try {
Callable
set()和setException负责保存结果到outcome和状态的流转。调用finishCompletion将阻塞的线程唤醒
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL);
// final state
finishCompletion();
}
}
protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL);
// final state
finishCompletion();
}
}
finishCompletion
方法的作用就是不管异步任务正常还是异常结束,此时都要唤醒且移除线程等待链表的等待线程节点,这个链表实现的是一个是Treiber stack
,因此唤醒(移除)的顺序是"后进先出"即后面先来的线程先被先唤醒(移除),关于这个线程等待链表是如何成链的,后面再继续分析。
// assert state > COMPLETING;
for (WaitNode q;
(q = waiters) != null;
) {
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {//这里为什么要把waiters设置为null
for (;
;
) {
Thread t = q.thread;
//对于waiters的结构比较困惑。看不懂遍历的过程
if (t != null) {
q.thread = null;
//唤醒等待结果的线程
LockSupport.unpark(t);
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null;
// unlink to help gc
q = next;
}
break;
}
}done();
callable = null;
// to reduce footprint
}
四、get方法实现:主要是调用awaitDone方法,判断当前状态看是否可以返回结果。对于不同的状态有不同的处理方式,而且可以设置阻塞的时间
get()方法的实现,当状态<=COMPLETING,会阻塞当前线程
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
|awaitDone()
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;
;
) {
if (Thread.interrupted()) {//如果当前获取任务执行结果的线程被中断,此时移除该线程WaitNode链表节点,并抛出InterruptedException
removeWaiter(q);
throw new InterruptedException();
}int s = state;
/**【问】此时将当前WaitNode节点的线程置空,其中在任务结束时也会调用finishCompletion将WaitNode节点的thread置空,
* 这里为什么又要再调用一次q.thread = null;
呢?
*【答】因为若很多线程来获取任务执行结果,在任务执行完的那一刻,此时获取任务的线程要么已经在线程等待链表中,要么
*此时还是一个孤立的WaitNode节点。在线程等待链表中的的所有WaitNode节点将由finishCompletion来移除(同时唤醒)所有
* 等待的WaitNode节点,以便垃圾回收;而孤立的线程WaitNode节点此时还未阻塞,因此不需要被唤醒,此时只要把其属性置为
*null,然后其有没有被谁引用,因此可以被GC。**/
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
//任务正在执行,让出线程
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
else if (q == null)//若当前线程等待节点还未入线程等待队列,此时加入到该线程等待队列的头部
q = new WaitNode();
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
LockSupport.park(this);
}
}
五、Future的优点和缺点
Future的优点就是结合Callable能够异步执行,然后返回结果。但是有以下局限
2. Future 的结果在非阻塞的情况下,不能执行更进一步的操作 Future 不会通知你它已经完成了,它提供了一个阻塞的
当你写了一个函数,用于通过一个远程API获取一个电子商务产品最新价格。因为这个 API 太耗时,你把它允许在一个独立的线程中,并且从你的函数中返回一个 Future。现在假设这个API服务宕机了,这时你想通过该产品的最新缓存价格手工完成这个Future 。你会发现无法这样做(CompletableFuture的complete方法可以手动完成)get()
方法通知你结果。你无法给 Future 植入一个回调函数,当 Future 结果可用的时候,用该回调函数自动的调用 Future 的结果。
2. 多个 Future 不能串联在一起组成链式调用 有时候你需要执行一个长时间运行的计算任务,并且当计算任务完成的时候,你需要把它的计算结果发送给另外一个长时间运行的计算任务等等。你会发现你无法使用 Future 创建这样的一个工作流。(CompletableFuture的thenApply等方法可以链式操作)
3. 不能组合多个 Future 的结果 假设你有10个不同的Future,你想并行的运行,然后在它们运行未完成后运行一些函数。你会发现你也无法使用 Future 这样做。(allOf函数)
4. 没有异常处理 (CompletableFuture使用 exceptionally() 回调处理异常)
【Future详解】参考:https://juejin.im/post/6844904199625375757
推荐阅读
- 我要做大厨
- 这辈子我们都不要再联系了
- 眼光要放高远
- 我们重新了解付费。
- 我要我们在一起(二)
- 螃蟹和这些食物同吃,轻则腹泻、重则中毒!要小心哦~
- 我执意要等,是因为我相信你一定会来
- 老了的父母
- 是你,情愿
- 火锅