1. Runnable、Callable、Future、FutureTask的区别与联系
和Java异步打交道就不能回避掉Runnable,Callable,Future,FutureTask等类，首先来介绍下这几个类的区别。
1.1 Runnable
Runnable接口是我们最熟悉的，它只有一个run函数。然后使用某个线程去执行该runnable即可实现多线程，Thread类在调用start()函数后就是执行的是Runnable的run()函数。Runnable最大的缺点在于run函数没有返回值。
1.2 Callable
Callable接口和Runnable接口类似，它有一个call函数。使用某个线程执行Callable接口实质就是执行其call函数。call方法和run方法最大的区别就是call方法有返回值：
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
} 1.3 Future
Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作。get方法会阻塞，直到任务返回结果(Future简介)。
1.4 FutureTask
Future只是一个接口，在实际使用过程中，诸如ThreadPoolExecutor返回的都是一个FutureTask实例。
public class FutureTask<V> implements RunnableFuture<V>
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
} 可以看到，FutureTask是一个RunnableFuture，而RunnableFuture实现了Runnbale又实现了Futrue这两个接口。
2 FutureTask的构造过程
事实上，通过ExecutorService接口的相关submit方法，实际上都是提交的Callable或者Runnable，包装成一个FutureTask对象。
public abstract class AbstractExecutorService implements ExecutorService {
...
//将Runable包装成FutureTask之后，再调用execute方法
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
//调用newTaskFor方法，利用Callable构造一个FutureTask对象
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
}可以看到AbstractExecutorService的submit方法调用后返回的就是一个FutureTask对象，接下来看下FutureTask的构造方法：
//接受Callable对象作为参数
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;
}
//接受Runnable对象作为参数
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);//将Runnable转为Callable对象
this.state = NEW;
}
//callable方法，将Runnable转为一个Callable对象，包装设计模式
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
//RunnableAdapter是Executors的一个内部类，实现了Callable接口
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;
}
}可以看到，构造FutureTask时，无论传入的是Runnable还是Callable，最终都实现了Callable接口。
3 FutureTask主要成员
接下来看下FutureTask类的主要成员变量：
public class FutureTask<V> implements RunnableFuture<V> {
/*
* FutureTask中定义了一个state变量，用于记录任务执行的相关状态 ，状态的变化过程如下
* NEW -> COMPLETING -> NORMAL
* NEW -> COMPLETING -> EXCEPTIONAL
* NEW -> CANCELLED
* NEW -> INTERRUPTING -> INTERRUPTED
*/
private volatile int state;
//主流程状态
private static final int NEW = 0; //当FutureTask实例刚刚创建到callbale的call方法执行完成前，处于此状态
private static final int COMPLETING = 1; //callable的call方法执行完成或出现异常时，首先进行此状态
private static final int NORMAL = 2;//callable的call方法正常结束时，进入此状态，将outcom设置为正常结果
private static final int EXCEPTIONAL = 3;//callable的call方法异常结束时，进入此状态，将outcome设置为抛出的异常
//取消任务执行时可能处于的状态
private static final int CANCELLED= 4;// FutureTask任务尚未执行，即还在任务队列的时候，调用了cancel方法，进入此状态
private static final int INTERRUPTING = 5;// FutureTask的run方法已经在执行，收到中断信号，进入此状态
private static final int INTERRUPTED = 6;// 任务成功中断后，进入此状态
private Callable<V> callable;//需要执行的任务，提示：如果提交的是Runnable对象，会先转换为Callable对象，这是构造方法参数
private Object outcome; //任务运行的结果
private volatile Thread runner;//执行此任务的线程
//等待该FutureTask的线程链表，对于同一个FutureTask，如果多个线程调用了get方法，对应的线程都会加入到waiters链表中，同时当FutureTask执行完成后，也会告知所有waiters中的线程
private volatile WaitNode waiters;
......
}FutureTask的成员变量并不复杂，主要记录以下几部分信息：
- 状态
- 任务（callable）
- 结果（outcome）
- 等待线程（waiters）
4 FutureTask的执行过程
4.1 run
接下来开始看一个FutureTask的执行过程，FutureTask执行任务的方法当然还是run方法：
public void run() {
//保证callable任务只被运行一次
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);
}
}- 如果状态不为new或者运行线程runner失败，说明当前任务已经被其他线程启动或者已经被执行过，直接返回false
- 调用call方法执行核心任务逻辑。如果调用成功则执行set(result)方法，将state状态设置成NORMAL。如果调用失败抛出异常则执行setException(ex)方法，将state状态设置成EXCEPTIONAL，唤醒所有在get()方法上等待的线程
- 如果当前状态为INTERRUPTING(步骤2已CAS失败)，则一直调用Thread.yield()直至状态不为INTERRUPTING
4.2 set、setException方法
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();
}
}两个方法的逻辑基本一致，先通过CAS操作将状态从NEW置为COMPLETING，然后再将最终状态分别置为NORMAL或者EXCEPTIONAL，最后再调用finishCompletion方法。
4.3 finishCompletion
private void finishCompletion() {
for (WaitNode q; (q = waiters) != null;) {
//通过CAS把栈顶的元素置为null，相当于弹出栈顶元素
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread;
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
}finishCompletion的逻辑也比较简单：
- 遍历waiters链表，取出每一个节点：每个节点都代表一个正在等待该FutureTask结果（即调用过get方法）的线程
- 通过 LockSupport.unpark(t)唤醒每一个节点，通知每个线程，该任务执行完成
4.4 get
在finishCompletion方法中，FutureTask会通知waiters链表中的每一个等待线程，那么这些线程是怎么被加入到waiters链表中的呢？上文已经讲过，当在一个线程中调用了get方法，该线程就会被加入到waiters链表中。所以接下来看下get方法：
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s);
}get方法很简答，主要就是调用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 (;;) {
//如果该线程执行interrupt()方法，则从队列中移除该节点，并抛出异常
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
//如果state状态大于COMPLETING 则说明任务执行完成，或取消
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
//如果state=COMPLETING，则使用yield，因为此状态的时间特别短，通过yield比挂起响应更快。
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);
//如果需要阻塞指定时间，则使用LockSupport.parkNanos阻塞指定时间
//如果到指定时间还没执行完，则从队列中移除该节点，并返回当前状态
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
//阻塞当前线程
else
LockSupport.park(this);
}
}整个方法的大致逻辑主要分为以下几步：
- 如果当前状态值大于COMPLETING，说明已经执行完成或者取消，直接返回
- 如果state=COMPLETING，则使用yield，因为此状态的时间特别短，通过yield比挂起响应更快
- 如果当前线程是首次进入循环，为当前线程创建wait节点加入到waiters链表中
- 根据是否定时将当前线程挂起（
LockSupport.parkNanosLockSupport.park）来阻塞当前线程，直到超时或者线程被finishCompletion方法唤醒 - 当线程挂起超时或者被唤醒后，重新循环执行上述逻辑
get方法是FutureTask中的关键方法，了解了get方法逻辑也就了解为什么当调用get方法时线程会被阻塞直到任务运行完成。
4.5 cancel
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;
}- 根据mayInterruptIfRunning是否为true，CAS设置状态为INTERRUPTING或CANCELLED，设置成功，继续第二步，否则返回false
- 如果mayInterruptIfRunning为true，调用runner.interupt()，设置状态为INTERRUPTED
- 唤醒所有在get()方法等待的线程
