常用方法
set & setException:
更新状态值,唤醒栈中等待的线程
protected void set(V v) {
// CAS 将 state 修改为 COMPLETING,该状态是一个中间状态
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v; // 输出结果赋值
// 将 state 更新为 NORMAL
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
protected void setException(Throwable t) {
// CAS 将 state 修改为 COMPLETING,该状态是一个中间状态
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t; // 输出结果赋值
// 将 state 更新为 EXCEPTIONAL
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();
}
}
这两个方法的操作类似,都是更新 state 的值并给返回结果 outcome 赋值,然后执行结束操作 finishCompletion 方法:
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
// 将 waiters 置空
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null;
// 唤醒 WaitNode 封装的线程
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
}
finishCompletion 方法的作用就是唤醒栈中所有等待的线程,并清空栈。其中的 done 方法实现为空:
protected void done() { }
子类可以重写该方法实现回调功能。
awaitDone:
等待任务执行完成
// Awaits completion or aborts on interrupt or timeout.
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;
// s > COMPLETING 表示任务已执行完成(包括正常执行、异常等状态)
// 则返回对应的状态值
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
// s == COMPLETING 是一个中间状态,表示任务尚未完成
// 这里让出 CPU 时间片
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
// 执行到这里,表示 s == NEW,将当前线程封装为一个 WaitNode 节点
else if (q == null)
q = new WaitNode();
// 这里表示 q 并未入栈,CAS 方式将当 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);
}
}
该方法的主要判断步骤如下:
这里是引用
若线程被中断,则响应中断;
若任务已完成,则返回状态值;
若任务正在执行,则让出 CPU 时间片;
若任务未执行,则将当前线程封装为 WaitNode 节点;
若 WaitNode 未入栈,则执行入栈;
若已入栈,则将线程挂起。
以上步骤是循环执行的,其实该方法的主要作用就是:当任务执行完成时,返回状态值;否则将当前线程挂起。
report:
封装返回结果
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);
}
cancel:
取消任务
public boolean cancel(boolean mayInterruptIfRunning) {
if (!(state == NEW &&
UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try { // in case call to interrupt throws exception
if (mayInterruptIfRunning) {
try {
// 若允许中断,则尝试中断线程
Thread t = runner;
if (t != null)
t.interrupt();
} finally { // final state
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
}
}
} finally {
finishCompletion();
}
return true;
}