java.util.concurrent解析——FutureTask源码解析

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.parkNanos LockSupport.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()方法等待的线程