1. 结论先行
1.1 FutreTask作用
引用官方文档的注释:A {@code Future} represents the result of an asynchronous computation( Future对象,表示一个异步计算的结果)
。即可以获取异步线程的返回值
1.2 用法
- 配合Thread使用
java
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 定义一个FutureTask任务
Future<String> strFuture = new FutureTask<>(() -> {
log.info("##开始执行异步任务##");
Thread.sleep(2000); // 休眠2s
return Thread.currentThread().getName(); // 返回异步线程的名称
});
Thread t = new Thread((Runnable) strFuture);
t.start();
log.info("111::" + Thread.currentThread().getName() + "线程正在运行!");
// 此处就可以处理其他逻辑
log.info("获取异步线程名称::" + strFuture.get());
log.info("222::" + Thread.currentThread().getName() + "线程正在运行!");
}
输出结果:
java
[2024-03-26 10:26:52] [INFO]: 111::main线程正在运行!
[2024-03-26 10:26:52] [INFO]: ##开始执行异步任务##
// 停顿了2秒,等待异步线程返回结果
[2024-03-26 10:26:54] [INFO]: 获取异步线程名称::Thread-0
[2024-03-26 10:26:54] [INFO]: 222::main线程正在运行!
- 配合线程池使用:
java
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 定义一个FutureTask任务
Future<String> strFuture = new FutureTask<>(() -> {
log.info("##开始执行异步任务##");
Thread.sleep(3000);
return Thread.currentThread().getName(); // 返回异步线程的名称
});
ThreadPoolExecutor executor = new ThreadPoolExecutor(2,4,5,
TimeUnit.MILLISECONDS,new ArrayBlockingQueue<>(40));
executor.submit((Runnable) strFuture);
log.info("111::" + Thread.currentThread().getName() + "线程正在运行!");
log.info("获取异步线程名称::" + strFuture.get());
log.info("222::" + Thread.currentThread().getName() + "线程正在运行!");
}
运行结果:
java
[2024-03-26 10:31:23] [INFO] : 111::main线程正在运行!
[2024-03-26 10:31:23] [INFO] : ##开始执行异步任务##
// 停顿了3秒,等待异步线程返回结果
[2024-03-26 10:31:26] [INFO] : 获取异步线程名称::pool-1-thread-1
[2024-03-26 10:31:26] [INFO] : 222::main线程正在运行!
2. 探索(源码)之旅
2.1 类结构
- 首先看一下FutureTask的继承,有个整体概念
FutureTask本质上也是实现了Runnable。同时实现了Future接口获取异步计算的功能。
- 接着看一下
FutureTask
的构造函数:有两个构造函数
java
// 接收一个callable对象
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
// 也可以接收一个runnable,但也会被装饰成一个callable
// result参数,其实就是返回值,从某种程度上说,返回值是写死的
public FutureTask(Runnable runnable, V result) {
// 将runnable封装成了一个callable对象
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
可以看出构造函数就是接收了一个callable对象,即使接收runnable,也把它装饰成了callable对象。我们分别看一下Callable
接口和封装过程:
java
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
将Runnable
封装为Callable
:
java
// Executors.callable方法:
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
// 就简单的封装成了一个RunnableAdapter对象
return new RunnableAdapter<T>(task, result);
}
// RunnableAdapter对象结构
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task; // 真正的任务
this.result = result;
}
public T call() {
task.run();
return result; // 返回值是写死的
}
}
- 了解完FutrueTask类继承结构和构造函数,再看一下它的几个重要成员变量:
java
/**
* 任务的运行状态,初始化是NEW状态。
* 只有在setException和cancel方法中,会把状态转化为 terminal(EXCEPTIONAL,CANCELLED) 状态。
* 在运行期间,state的值可能会短暂的变成COMPLETING(outcome值被赋值时)或者INTERRUPTING(只有
* 试图中断线程,且调用了cancel(true)方法)。
*
* 任务运行状态的几种转化形态:
* NEW -> COMPLETING -> NORMAL
* NEW -> COMPLETING -> EXCEPTIONAL
* NEW -> CANCELLED
* NEW -> INTERRUPTING -> INTERRUPTED
*/
private volatile int state;
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; // 已手动中止任务
/** 任务对象; 执行任务结束后,置为null */
private Callable<V> callable;
/** 任务执行的结果或者抛出的异常对象 */
private Object outcome; // non-volatile, protected by state reads/writes
/** 执行callable的任务线程; CASed during run() */
private volatile Thread runner;
/** 不知道咋翻译,看后续源码理解 */
private volatile WaitNode waiters;
- 另外再补充一个FutureTask中使用UNSAFE类cas操作的知识,源码中有用到:
java
// FutureTask类中使用了UNSAFE类,进行CAS操作
private static final sun.misc.Unsafe UNSAFE;
private static final long stateOffset; // state变量在JVM中游标位置
private static final long runnerOffset; // runner变量在JVM中游标位置
private static final long waitersOffset; // waiters变量在JVM中游标位置
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> k = FutureTask.class;
// 获取游标位置
stateOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("state"));
runnerOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("runner"));
waitersOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("waiters"));
} catch (Exception e) {
throw new Error(e);
}
}
// 在本次阅读源码中用到UNSAFE的两个方法:
/**
* 当指定实例{var1}的成员变量{var2}的值和我们期望的值{var4}相等时,则将新值{var5}赋予该变量{var2}
*
* @param var1 包含要修改的 int 值的对象的引用
* @param var2 要修改的 int 值在对象中的偏移量(从对象的内存地址开始计算的字节数)。
* @param var4 期望值(即我们期望在对象当前位置的值)。
* @param var5 新值(如果期望的值与当前值匹配,则设置此新值)
*/
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
/**
* 当指定实例{var1}的成员变量{var2}的值和我们期望的值{var4}相等时,则将新值{var5}赋予该变量{var2}
*
* @param var1 包含要修改的 对象 值的对象的引用。
* @param var2 要修改的 对象 值在对象中的偏移量(从对象的内存地址开始计算的字节数)。
* @param var4 期望值(即我们期望在对象当前位置的值)。
* @param var5 新值(如果期望的值与当前值匹配,则设置此新值)
*/
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
只要知道compareAndSwapInt和compareAndSwapObject两个方法的作用即可。
2.2 流程逻辑
FutureTask
代表异步计算的结果,实现了runnable
接口,那么它的入口必定是run()
方法:
java
public void run() {
// 检查任务运行状态
if (state != NEW ||
// 赋值 runner 对象,赋值失败,直接return(就是把当前正在运行的thread对象赋值给runner)
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
// 再次判断任务的运行状态;任务对象非null
if (c != null && state == NEW) {
V result;
boolean ran; // 任务是否执行成功
try {
result = c.call(); // 执行真正的任务逻辑
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex); // 执行任务异常,设置运行状态为EXCEPTIONAL,并赋值到outcome
}
if (ran)
// 如果任务正常运行结束,设置运行状态为NORMAL,并赋值到outcome
set(result);
}
} finally {
// 直到state状态尘埃落定后,runner 变量才可以被置null
// 防止run()方法被重复调用,导致线程安全问题
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
// 若任务线程被中断,死循环到任务状态为INTERRUPTED
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
这里的整体逻辑其实比较简单,就是调用的callable对象的call()
方法,将返回值赋值给outcome:
java
/**
* 任务正常执行结束,将结果赋值给outcome,将运行状态设置为:NORMAL
*/
protected void set(V v) {
// 判断state状态正确,并赋值为COMPLETING
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
// 将state赋值为NORMAL
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion(); // 做任务结束处理
}
}
执行任务逻辑抛异常处理:
java
/**
* 运行任务异常,将运行状态设置为:EXCEPTIONAL
*/
protected void setException(Throwable t) {
// 判断state状态正确,并赋值为COMPLETING
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
// 将state赋值为EXCEPTIONAL
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion(); // 做任务结束处理
}
}
执行任务的逻辑比较简单,稍微复杂点的是获取结果的逻辑。Future
提供了两个get()
方法来获取返回值:
java
/**
* 获取处理结果
*/
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING) // 判断任务状态,若未执行结束,则阻塞等待
s = awaitDone(false, 0L);
return report(s); // 返回结果,注意该对象若是Exception,会抛出异常
}
/**
* 获取处理结果,设置等待时间,超时抛异常
*/
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
if (s <= COMPLETING && // 判断任务状态
// 超时后,状态仍为未完成状态(NEW,COMPLETING),则抛异常
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s); // 返回结果,注意该对象若是Exception,会抛出异常
}
看下awaitDone()
方法:
java
/**
* 等待计算结果 或者 在线程被中断或者超时时放弃等待
*
* @param timed true时,会判断超时
* @param nanos 设置等待超时的时间
* @return 计算结束后的state
*/
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()) { // 线程已经收到中断信号
removeWaiter(q); // 移除等待节点
throw new InterruptedException();
}
int s = state;
if (s > COMPLETING) { // 任务处理已经结束
if (q != null)
q.thread = null;
return s;
}
else if (s == COMPLETING) // 任务已经处理完毕,但还未到最终状态
Thread.yield(); // 主动释放cpu,等待被唤醒
else if (q == null) // 如果WaitNode对象为空,创建一个新的
q = new WaitNode();
else if (!queued)
// 将上一行创建的WaitNode赋值给成员变量waiters
// 这里是为了任务执行完毕后,能够唤醒"查询结果"的线程
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);
}
}
等待结果的逻辑,我们主要关注WaitNode()
对象,我们先看下它的结构:
java
static final class WaitNode {
volatile Thread thread;
volatile WaitNode next;
WaitNode() { thread = Thread.currentThread(); }
}
结构很简单,保存了一个当前thread对象和一个next节点。然后我们一步一步分析awaitDone()
方法中关于WaitNode
对象的逻辑:
- 当我们调用get()方法时,假设任务逻辑还在执行,逻辑肯定进入到
q == null
判断分支中,它实例化了一个WaitNode
对象,将当前调用get()
方法的Thread
对象放到了WaitNode
对象中,且将WaitNode
值赋给变量q
。 awaitDone()
方法中的for循环进行第二次循环,此时我们再假设任务还在运行中。此时,逻辑进入到!queued
的判断分支中,此时q.next = waiters
返回的是null,和waitersOffset游标指向的变量(waiters)是相等的,cas操作判断正常。将q对象赋值给了成员变量waiters
。- 若任务还在运行中,没有结束,在后面的循环中,要么进入
timed
判断分支,要么就是最后的else
判断分支,都是挂起当前线程,阻塞等待了。 - 此时我们再回过来看
run()
方法,任务执行结束后,设置state为最终状态时(setException()和set()
方法)是不是都调用了finishCompletion()
,我们来细究一下:
java
private void finishCompletion() {
// 成员属性waiters 不为空,说明主线程在等待"任务"结果,就是步骤2干的事
for (WaitNode q; (q = waiters) != null;) {
// 将成员属性waiters置为null(cas判断操作)
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread; // 获取主线程的thread对象(在步骤1中赋值的)
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
}
这样awaitDone()
方法就会在等待任务执行结束后,返回任务状态。我们再返回来看get()
方法中的report()
方法逻辑:
java
private V report(int s) throws ExecutionException {
Object x = outcome;
if (s == NORMAL) // 要是任务正常结束,则正常返回结果值
return (V)x;
// 根据任务没有正常结束,根据任务的状态抛出不同的异常
if (s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
}
至此FutureTask的主线逻辑都已清晰。支线逻辑(中断任务线程等),自个再看看,加深源码阅读的理解和兴趣。
3. 总结
整体流程: