一、Future接口
Future接口表示异步任务的结果，提供了cancel取消、isDone是否已完成、get无限等待或超时等待获取结果等操作，源码如下：
public interface Future<V> {
// 尝试取消任务的执行
// 如果mayInterruptIfRunning为true，则尝试中断该线程
boolean cancel(boolean mayInterruptIfRunning);
// 判断是否在完成前取消
boolean isCancelled();
// 判断是否已完成
boolean isDone();
// 无限等待获取结果，支持中断
V get() throws InterruptedException, ExecutionException;
// 超时等待获取结果，支持中断
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}二、FutureTask
FutureTask实现了Runnable和Future接口，所以它既是任务，也是异步任务的结果。如下类图
在ThreadPoolExecutor线程池执行器submit提交任务时，会返回一个Future（如果调用的是execute，则不会返回Future），那么这个Future其实是一个FutureTask对象，它会将传进来的Runnable任务封装为FutureTask，再将封装后的FutureTask传入execute()方法中，并直接返回该FutureTask，源码如下：
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
// 调用具体子类的execute方法
execute(ftask);
return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}当我们提交任务之后拿到了这个FutureTask之后，就可以调用Future接口提供的各种操作（如cancel取消任务、isDone是否已完成、get无限等待或超时等待获取结果）。那么FutureTask是如何来具体实现这些操作的呢？
2.1 关键属性
FutureTask内部有几个关键属性，如下：
- Callable<V> callable：对应的任务
- Object outcome：任务完成的结果或抛出的异常
- Thread runner：运行该任务的线程
- WaitNode waiters：等待FutureTask完成的线程（可以有多个，以单链表的形式存储）
2.2 状态管理
FutureTask通过对任务状态的管理，来实现各种操作，状态有以下几种：
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; // 已中断可能存在的状态转换，有以下几种：
- NEW -> COMPLETING -> NORMAL
- NEW -> COMPLETING -> EXCEPTIONAL
- NEW -> CANCELLED
- NEW -> INTERRUPTING -> INTERRUPTED
2.3 任务的运行过程
当我们向ThreadPoolExecutor进行submit提交任务时，内部执行了execute(FutureTask)方法，其实质就是工作线程执行FutureTask任务的run方法，所以这里要看一下FutureTask的run方法是如何来切换任务状态的？
大致流程如下：
- 判断任务状态是否为NEW，如果不为NEW，表示任务已执行，则本次不执行该任务，直接返回
- 否则调用callable.call()执行任务
- 如果任务正常完成，设置结果outcome为call()方法的返回值，修改任务状态为NORMAL，并唤醒等待线程waiters
- 如果任务执行过程中有异常，设置结果outcome为所抛出的异常，修改任务状态为EXCEPTIONAL，并唤醒等待线程waiters
结合源码来看，如下：
public void run() {
// 当任务状态不为NEW时，直接返回
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
ran = true;
} catch (Throwable ex) {
result = null;
// 如果有异常，则ran为false
ran = false;
// 将outcome设置为ex，修改任务状态为EXCEPTIONAL，并唤醒等待线程
setException(ex);
}
// 如果正常完成，将outcome设置为result，修改任务状态为NORMAL，并唤醒等待线程
if (ran)
set(result);
}
} finally {
runner = null;
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}2.4 取消任务
通过调用cancel(mayInterruptIfRunning)方法尝试取消任务的执行。
- 如果任务状态不为初始状态NEW，直接返回false，表示取消失败。
- 否则进一步判断mayInterruptIfRunning，如果为true，将任务状态修改为INTERRUPTING，如果是flase，则将任务状态修改为CANCELLED。
- 判断mayInterruptIfRunning是否为true，如果是，则调用runner线程的interrupt()中断方法，并将任务状态修改为INTERRUPTED
- 最终唤醒正在等待的线程waiters
- 返回true，表示取消成功
源码如下：
public boolean cancel(boolean mayInterruptIfRunning) {
// 判断如果state不为NEW，则直接返回false，否则通过CAS尝试修改state的值
if (!(state == NEW &&
UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try {
// 如果mayInterruptIfRunning为true，调用线程的interrupt()方法
if (mayInterruptIfRunning) {
try {
Thread t = runner;
if (t != null)
t.interrupt();
} finally { // final state
// 更新state为INTERRUPTED，putOrderedInt不保证立即对其他线程可见
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
}
}
} finally {
// 唤醒正在等待的线程
finishCompletion();
}
return true;
}2.5 无限等待或超时等待任务结果
可以通过get()来可中断的无限等待或超时等待任务的结果，如下：
public V get() throws InterruptedException, ExecutionException {
int s = state;
// 如果状态 <= COMPLETING，则无限等待，直到被唤醒或中断
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;
// 如果状态 <= COMPLETING，则进行超时等待
// 如果超时等待后，任务依然还没有完成，则抛出TimeoutException异常
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s);
}那么接下来就来看下awaitDone()方法的具体实现，源码如下：
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
// 计算最后期限deadline
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
// 如果线程被中断，从waiters中移除，并直接抛出InterruptedException异常
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
// 判断如果任务状态 > COMPLETING，说明任务已经完成，直接返回任务状态
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
// 判断任务状态 == COMPLETING，说明任务还没有完成，但是即将完成
// 所以如果任务状态一直为COMPLETING，则会一直死循环
else if (s == COMPLETING)
Thread.yield();
else if (q == null) // 如果走到这里，说明任务状态为NEW，则创建一个等待节点
q = new WaitNode();
else if (!queued) // 走到这里，说明该等待节点还没有入队，则通过CAS将该等待节点插到链表头部
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) { // 如果为超时等待
nanos = deadline - System.nanoTime();
// 如果nanos <= 0，说明已经超时，从waiters中移除，并返回任务状态
// 否则说明还没有超时，通过LockSupport.parkNanos来限时挂起
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
// 将当前线程挂起
LockSupport.park(this);
}
}可以看到，awaitDone()内部还是通过LockSupport.park()或parkNanos()方法来将线程挂起或限时挂起来实现的。
java
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。