1. 常量和变量
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;
// run正常执行：NEW -> COMPLETING -> NORMAL
// run异常执行：NEW -> COMPLETING -> EXCEPTIONAL
// cancel(false)：NEW -> CANCELLED
// cancel(true)：NEW -> INTERRUPTING -> INTERRUPTED
private Callable<V> callable; // 任务
private Object outcome; // 执行结果
private volatile Thread runner; // 任务执行线程（在run方法中置为当前线程）
private volatile WaitNode waiters; // 任务等待链表（头节点）
2. 构造方法
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result); // RunnableAdapter implements Callable
this.state = NEW;
}
3. 等待节点
static final class WaitNode {
volatile Thread thread; // 等待线程
volatile WaitNode next; // 下一等待节点
WaitNode() { thread = Thread.currentThread(); }
}
4. 实现Future接口
1）cancel
public boolean cancel(boolean mayInterruptIfRunning) {
// 任务状态为NEW && CAS设置state = INTERRUPTING || CANCELLED
if (!(state == NEW && UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try {
if (mayInterruptIfRunning) { // 允许在任务执行时被中断
try {
Thread t = runner;
if (t != null) // 任务尚未执行完毕
t.interrupt(); // 中断任务所在线程
} finally {
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // state = INTERRUPTED
}
}
} finally {
finishCompletion(); // 唤醒所有等待任务执行结果的线程（见get和awaitDone方法）
}
return true;
}
private void finishCompletion() {
for (WaitNode q; (q = waiters) != null;) { // 从头节点（q）开始遍历waiters链表
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) { // CAS设置waiters链表为空
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null; // 标记节点q被唤醒
LockSupport.unpark(t); // 唤醒线程
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null;
q = next;
}
break;
}
}
done(); // noop
callable = null;
}
protected void done() { }
2）isCancelled和isDone
public boolean isCancelled() { // 任务是否已取消执行
return state >= CANCELLED;
}
public boolean isDone() { // 任务是否执行完毕（对外如此，对内是 <= COMPLETING）
// cancel方法直接设置任务状态为INTERRUPTING || CANCELLED，run方法中在set执行结果时设置任务状态为COMPLETING
return state != NEW;
}
3）get
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L); // 永久等待
return report(s);
}
public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
// 在timeout时间内等待
if (s <= COMPLETING && (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s);
}
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();
else if (q == null) // 任务尚未执行（s == NEW），则建立任务等待节点q
q = new WaitNode();
else if (!queued) // q尚未排队，则CAS设置q为头节点
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); // 在naos时间内等待
}
else
LockSupport.park(this); // 永久等待
}
}
private void removeWaiter(WaitNode node) {
if (node != null) {
node.thread = null;
retry:
for (;;) {
// pred被唤醒 || CAS(waiters)失败：回到此处
for (WaitNode pred = null, q = waiters, s; q != null; q = s) { // 从头节点（q）开始遍历waiters链表
s = q.next;
if (q.thread != null) // q未被唤醒
pred = q;
else if (pred != null) { // q已被唤醒 && q前存在未被唤醒节点
pred.next = s; // 在链表中删除p
if (pred.thread == null) // pred被唤醒（其它线程正在同步finishCompletion：cancel || run） || pred超时（其它线程正在同步removeWaiter）
continue retry;
}
// q已被唤醒 && q前不存在未被唤醒节点，则CAS设置头节点为q.next
else if (!UNSAFE.compareAndSwapObject(this, waitersOffset, q, s))
continue retry;
}
break;
}
}
}
5. 实现Runnable接口
public void run() {
// 任务未开始执行 || CAS设置runner = Thread.currentThread失败
if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true; // 执行成功
} catch (Throwable ex) {
result = null;
ran = false; // 执行失败
setException(ex); // 设置异常的执行结果
}
if (ran)
set(result); // 设置正常的执行结果
}
} finally {
runner = null;
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s); // 任务可能正在被其它线程cancel：等待cancel的完成
}
}
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { // CAS设置state = COMPLETING（任务可能已被cancel）
// CAS(state)成功
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // state = NORMAL
finishCompletion(); // 唤醒所有任务等待节点
}
}
protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { // CAS设置state = COMPLETING（任务可能已被cancel）
// CAS(state)成功
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // state = EXCEPTIONAL
finishCompletion(); // 唤醒所有任务等待节点
}
}
private void handlePossibleCancellationInterrupt(int s) {
if (s == INTERRUPTING)
while (state == INTERRUPTING)
Thread.yield();
}
6. Unsafe
private static final sun.misc.Unsafe UNSAFE;
private static final long stateOffset;
private static final long runnerOffset;
private static final long waitersOffset;
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);
}
}
