FutureTask源码完整解读

1 简介

上一篇博客“异步任务服务简介”对FutureTask做过简要介绍与分析，这里再次对FutureTask做一次深入的分析（基于JDK1.8）。

FutureTask同时实现了Future 、Runnable接口，因此它可以交给执行器Executor去执行这个任务，也可以由调用线程直接执行run方法。

根据FutureTask.run方法的执行状态，可将其分为以下3种状态

①未启动： run方法还未被执行，FutureTask处于未启动状态。

②已启动: run方法在执行过程中，FutureTask处于已启动状态

③已完成：run方法正常完成返回或被取消或执行过程中因异常抛出而非正常结束，FutureTask处于已完成状态。

当FutureTask处于未启动或已启动状态时，执行FutureTask.get()方法将导致调用线程阻塞；当FutureTask处于已完成状态时，执行FutureTask.get()方法将导致调用线程立即返回结果或抛出异常。

当FutureTask处于未启动状态时，执行FutureTask.cancel()方法将导致此任务永远不会被执行；当FutureTask处于已启动状态时，执行FutureTask.cancel(true)方法将以中断执行此任务线程的方式来试图停止任务；当FutureTask处于已启动状态时，执行 FutureTask.cancel(false)方法将不会对正在执行此任务的线程产生影响（让正在执行的任务运行完成）；当FutureTask处于已完成状态时，执行FutureTask.cancel方法将返回false (已完成的任务任务无法取消)。

2 用法示例

FutureTask因其自身继承于Runnable接口，因此它可以交给执行器Executor去执行；另外它也代表异步任务结果，它还可以通过ExecutorService.submit返回一个FutureTask。另外FutureTask也可单独使用。为了更好的理解FutureTask ，下面结合ConcurrentHashMap演示一个任务缓存。缓存中有多个任务，使用多线程去执行这些任务，一个任务最多被一个线程消费，若多个线程试图执行这一个任务，只允许一个线程来执行，其他线程必须等待它执行完成。

import java.util.concurrent.*;

public class FutureTaskTest {
    private final ConcurrentMap<String, Future<String>> taskCache = new ConcurrentHashMap<>();
    public  String executionTask(final String taskName)
            throws ExecutionException, InterruptedException {
        while (true) {
            Future<String> future = taskCache.get(taskName);// 从缓存中获取任务
            if (future == null) {//不存在此任务，新构建一个任务放入缓存，并启动这个任务
                Callable<String> task = () ->{
                    System.out.println("执行的任务名是"+taskName);
                    return taskName;
                } ; // 1.2创建任务
                FutureTask<String> futureTask = new FutureTask<String>(task);
                future = taskCache.putIfAbsent(taskName, futureTask);// 尝试将任务放入缓存中
                if (future == null) {
                    future = futureTask;
                    futureTask.run();//执行任务
                }
            }
            try { //若任务在缓存中了，可以直接等待任务的完成
                return future.get();// 等待任务执行完成
            } catch (CancellationException e) {
                taskCache.remove(taskName, future);
            }
        }
    }

    public static void main(String[] args)    {
     final   FutureTaskTest taskTest = new FutureTaskTest();
        for (int i = 0; i < 7; i++) {
            int finalI = i;
            new Thread(()->{
                try {
                    taskTest.executionTask("taskName" + finalI);
                } catch (ExecutionException | InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
            new Thread(()->{
                try {
                    taskTest.executionTask("taskName" + finalI);
                    taskTest.executionTask("taskName" + finalI);
                } catch (ExecutionException | InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

打印输出

执行的任务名是taskName0

执行的任务名是taskName5

执行的任务名是taskName4

执行的任务名是taskName6

执行的任务名是taskName3

执行的任务名是taskName1

执行的任务名是taskName2

3 实现原理

1) 成员变量

它有一个成员变量state表示状态

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;//任务被中断(中断的最终状态)

state可能有这几种状态转换

/** NEW -> COMPLETING -> NORMAL      正常结束任务时的状态转换流程
     * NEW -> COMPLETING -> EXCEPTIONAL   任务执行过程中抛出了异常时的状态转换流程
     * NEW -> CANCELLED                 任务被取消时的状态转换流程
     * NEW -> INTERRUPTING -> INTERRUPTED  任务执行过程中出现中断时的状态转换流程
     */

其他成员变量

private Callable<V> callable;
private Object outcome; // non-volatile, protected by state reads/writes
private volatile Thread runner;
private volatile WaitNode waiters;

成员变量callable表示要执行的任务，

成员变量outcome表示任务的结果或任务非正常结束的异常

成员变量runner表示执行此任务的线程

成员变量waiter表示等待任务执行结果的等待栈(数据结构是单向链表) 。WaitNode是一个简单的静态内部，一个成员变量thread表示等待结果的线程，另一个成员变量next表示下一个等待节点（线程）。

static final class WaitNode {
    volatile Thread thread;
    volatile WaitNode next;
    WaitNode() { thread = Thread.currentThread(); }
}

2) 构造方法

FutureTask的构造方法会初始化callable和state ，它有两个构造方法， 分别接受Callable和Runnable类型的待执行任务。但对于Runnable类型参数，它会调用Executors.callable将Runnable转换为Callable类型实例，以便于统一处理。

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}

Executors.callable方法也很简单，它就返回了一个Callable的实现类RunnableAdapter类型的对象。

public static <T> Callable<T> callable(Runnable task, T result) {
    if (task == null)
        throw new NullPointerException();
    return new RunnableAdapter<T>(task, result);
}
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;
    }
}

3) 主要API

(1) run与runAndReset

run方法是Funture最重要的方法，FutureTask的一切都是从run方法开始的，它是执行callable任务的方法。

public void run() {
        if (state != NEW ||
                !UNSAFE.compareAndSwapObject(this, runnerOffset,
                        null, Thread.currentThread()))
            //将当前线程设置为执行任务的线程，CAS失败就直接返回
            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 must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null; //state已是最终状态，不再变化，将runer设为null,防止run方法被并发调用
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state; //清空运行线程runner后再重新获取state,防止遗漏掉对中断的处理
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

其主要逻辑是：

①检查状态，设置运行任务的线程

②调用callable的call方法去执行任务，并捕获运行中可能出现的异常

③如果任务正常完成，调用set设置任务的结果，将state设为NORMAL, 将结果保存到outcome ,唤醒所有等待结果的线程

④若执行任务过程中发生了异常，调用setException设置异常,将state设为EXCEPTIONAL ，将此异常也保存到outcome ，唤醒所有等待结果的线程

⑤最后将运行线程runner清空，若状态可能是任务被取消的中断还要处理此中断。

set 、setException方法分别用来设置结果、设置异常，但这仅是它们的主要逻辑，它们还会进行其他的处理。

它们会将结果或异常设置到成员变量outcome上，还会更新状态state，最后调用finishCompletion从等待栈表中移除并唤醒所有（节点）线程(任务已完成，无需要等待，可以直接获取结果，等待栈已没有存在的意义了)。

protected void setException(Throwable t) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = t;
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
        finishCompletion();
    }
}
protected void set(V v) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = v;
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        finishCompletion();
    }
}

run方法中有对中断的处理，我们来看看handlePossibleCancellationInterrupt方法怎么处理中断的.

这里就是简单地使当前线程让出时间片，让其他线程先执行任务，即线程礼让。

private void handlePossibleCancellationInterrupt(int s) {
        if (s == INTERRUPTING)
            while (state == INTERRUPTING)
                Thread.yield(); // wait out pending interrupt
    }

runAndReset方法是FutureTask类自己添加的protected级别的方法（供子类调用）, 这个方法主要用来执行可多次执行且不需要结果的任务，只有在任务运行和重设成功时才返回true 。定时任务执行器ScheduledThreadPoolExecutor的静态内部ScheduledFutureTask的run方法调用了这个API.

和run方法相比，runAndSet方法与之逻辑大致相同，只是runAndSet没用调用set方法设置结果(本身不需要结果，也是出于防止state被修改的目的)

protected boolean runAndReset() {
        if (state != NEW ||
                !UNSAFE.compareAndSwapObject(this, runnerOffset,
                        null, Thread.currentThread()))
            //任务已启动或CAS设置运行任务的的线程失败，直接返回false
            return false;
        boolean ran = false;
        int s = state;
        try {
            Callable<V> c = callable;
            if (c != null && s == NEW) {
                try {
                    c.call(); // don't set result  没有调用set(V)方法，不设置结束
                    ran = true;
                } catch (Throwable ex) {
                    setException(ex);
                }
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
        return ran && s == NEW; //任务成功运行且state还是NEW时返回true,反之返回false
    }

(2) get方法

get方法用于获取任务的最终结果，它有两个版本，其中一个是超时版本。两个版本的最主要的区别在于，非超时版本可以不限时长地等待结果返回 ,另外非超时版本不会抛出TimeoutException超时异常。get方法超时版本的基本逻辑：若任务未完成就等待任务完成，最后调用report报告结果，report会根据状态返回结果或抛出异常。

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);//awaitDone第一个参数为false，表示可以无限时长等待
    return report(s);
}
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();//到了限定时间，任务仍未完成，抛出超时异常TimeoutException
    return report(s);//报告结果
}

get方法的核心实现在于调用awaitDone方法，awaitDone用于等待任务的结果，若任务未完成awaitDone会阻塞当前线程。

awaitDone方法的基本逻辑：①若执行任务时出现了中断，则抛出InterruptedException异常;②若此时任务已完成，就返回最新的state，③若任务即将完成就使当前线程让出CPU时间片，让其他线程先执行；④若任务还在执行中，就将当前线程加入到等待栈中，然后让当前线程休眠直到超出限定时间或等待任务完成时run方法调用finishCompletion唤醒线程(run方法中的set或setException调用finishCompletion，而finishCompletion又会调用LockSupport.unpark).

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) // cannot time out yet
            Thread.yield();
        else if (q == null) 
            //初始化当前线程对应的节点
            q = new WaitNode();
        else if (!queued)
            //如果之前入栈失败，再次尝试入栈（CAS更新），将当前节点设为等待栈的栈顶
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                    q.next = waiters, q);
        else if (timed) { //如果设置了超时时间
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) { 
                //如果任务执行时长已经超出了给定的时间，从等待栈中移除当前节点（线程）
                removeWaiter(q);
                return state;
            }
            //让当前线程休眠等待给定的时间(或等到run方法中的set或setException调用finishCompletion来唤醒)
            LockSupport.parkNanos(this, nanos);
        }
        else//未设置超时时间
      //让当前线程无限时长休眠等待，直到任务完成时run方法中的set或setException调用finishCompletion来唤醒此线程
            LockSupport.park(this);
    }
}

上面的awaitDone方法中调用removeWaiter来移除等待栈表的中断和超时节点。

其内部实现不容易理解，但主要逻辑还是很清楚的：从头到尾遍历链表，将链表中的中断/超时节点移除出链表，若有线程竞争就重头开始再次遍历链表检查并移除无效节点。

private void removeWaiter(WaitNode node) {
    if (node != null) {
        node.thread = null; //先将节点对应的线程清空,下面的"q.thread != null"就能判断节点是否超时或中断节点。
        retry:
        for (;;) {          // restart on removeWaiter race
            //q表示当前遍历到的节点，pred表示q的前驱节点，s表示q的后继节点 
            for (WaitNode pred = null, q = waiters, s; q != null; q = s) {//遍历完链表才能退出内循环
                s = q.next;
                //q.thread!=null 表示这不是超时或中断的节点，它是效节点，不能被从栈表中移除
                //（removeWaiter的开头将超时或中断的节点在thread赋空,可见node.thread=null代码）
                if (q.thread != null)
                    pred = q; //得到下次循环时q的前驱节点
                else if (pred != null) { //q.thread== null 且pred！=null,需要将无效节点q从栈表中移除
                    //将q的前驱、后继节点直接链接在一起，q本身被移除出栈表了
                    pred.next = s;
                    //这里是从前向后遍历链表的，无竞争情况下，不可能没检查到当前节点的前面还有无效节点，
                    //那么一定有其他线程修改了当前节点q的前驱，些时有线程竞争，需要从链表的头部重新遍历检查
                    if (pred.thread == null) // check for race
                        continue retry;
                }
                // pred==null且q.thread=null
                //q的前驱节点为空，表明q是链表的头节点
                //q.thread==null，表明q是无效节点
                //无效节点不能作为链表的头节点，所以要更新头节点，将q的后继节点s作为链表新的头节点
                else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,  //CAS更新头节点
                        q, s))
                    //CAS更新失败，重试
                    continue retry;
            }
            break;
        }
    }
}

get方法需要调用report方法来报告结果，而report方法的基本逻辑也简单：若是任务正常结束就返回这个任务的结果，若是任务被取消，就抛出CancellationException异常，若是在执行任务过程中发生了异常就将其统一封装成ExecutionException并抛出。

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);
}

(3) cancel方法

cancel方法用于取消任务，我们可以看看cancel(boolean)方法如何实现的

public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&
            UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
                    mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        //①不是NEW状态，表示任务至少是COMPLETING(即将结束)状态，返回false
        //②CAS更新state为INTERRUPTING或CANCELLED失败，返回false
        //只有state状态更新成功，才能取消任务（防止被并发调用）
        return false;
    try {    // in case call to interrupt throws exception
        if (mayInterruptIfRunning) {//允许中断就设置中断标志
            try {
                Thread t = runner;
                if (t != null)
                    t.interrupt();//设置中断标志
            } finally { // final state 设置中断的最终状态
                //INTERRUPTING -> INTERRUPTED ,将state由“正在中断”更新为”已经中断“
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    } finally {
        //从等待栈上唤醒并移除所有的线程(节点)
        finishCompletion();
    }
    return true;
}

其基本逻辑：

①任务已结束或被取消，返回false

②若mayInterruptIfRunning为true,调用interrupt设置中断标志，将state设置为INTERRUPTED,若mayInterruptIfRunning为false，将state设为CANCELLED.

③调用finishCompletion唤醒并移除等待栈中的所有线程

finishCompletion()主要是处理任务结束后的扫尾工作，其主要逻辑是：将等待栈waiters赋空，唤醒并移除等待栈上的所有节点(线程)，最后再将任务callable赋空。

private void finishCompletion() {
    // assert state > COMPLETING;
    for (WaitNode q; (q = waiters) != null;) {
        //任务取消后，等待栈表没有存在的意义了，将等待栈waiters赋为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 将节点next属性清空，方便垃圾回收
                q = next;//向后移动一个节点
            }
            break;
        }
    }
    done();//空方法，留给子类重写
    callable = null; //赋空，减少痕迹       // to reduce footprint 
}

 

(4) 其他辅助方法

isCancelled方法返回任务是否被取消的布尔值

isDone方法返回任务是否完成的布尔值(非正常结束也行)

isCancelled 、isDone都是直接根据state确定任务的状态。

public boolean isCancelled() {
    return state >= CANCELLED;
}

public boolean isDone() {
    return state != NEW;
}