并发编程：你真的了解FutureTask吗？

FutureTask是什么

public interface Runnable {    public abstract void run();}Student implements RunnableThread xiaoming = new Thread(new Student());xiaoming.start();

我们知道Runnable是一个接口，它用来承载的是具体的任务，交给Thread执行。qhh28资讯网——每日最新资讯28at.com

qhh28资讯网——每日最新资讯28at.com

有这样一个场景：主线程执行一个任务（理解为调用一个方法）需要获取这个任务的返回值，然后再去执行另一个任务获取返回值，最后将两个返回值做其他处理，一般情况下耗时为两个任务的耗时和，如果想提高性能，可以用异步的方式，可以将任务一包装为Runnable，交给子线程执行，主线程执行第二个任务，这样就节省了一部分耗时，但是Runnable不支持返回值，所以行不通，而FutureTask就是解决这个问题的。qhh28资讯网——每日最新资讯28at.com

FutureTask的类图如下：qhh28资讯网——每日最新资讯28at.com

qhh28资讯网——每日最新资讯28at.com

看图可以知道两个事：qhh28资讯网——每日最新资讯28at.com

• 实现了Runnable接口，所以FutureTask也是一个可以承载任务的任务类。
• 实现了Future接口，Future接口提供了任务操作和获取返回值等方法，利用Future接口可以获取任务执行状态，取消任务，获取任务返回值等。

所以说FutureTask就是一个实现了一套获取返回值机制的任务体，请注意它依然是任务体，自身不能执行任务，依然需要借助Thread执行。qhh28资讯网——每日最新资讯28at.com

FutureTask应用例子

Callable<Integer> callableTask = () -> {    // 一些耗时的计算    return 42;};FutureTask<Integer> futureTask = new FutureTask<>(callableTask);Thread thread = new Thread(futureTask);thread.start();try {    Integer result = futureTask.get(); // 阻塞直到任务完成并返回结果    System.out.println("任务结果：" + result);} catch (InterruptedException | ExecutionException e) {    e.printStackTrace();}

上面就是使用案例，看起来写法比较复杂，其实一旦理解就不复杂了，首先我们上面说了FutureTask实现了Runnable，所以它是任务体，任务体需要依赖Thread执行，所以这里FutureTask和Runnable的写法一样都是作为Thread的入参。qhh28资讯网——每日最新资讯28at.com

代码中可以看到还有一个Callable类，这个其实也是任务体，它的源码如下：qhh28资讯网——每日最新资讯28at.com

public interface Callable<V> {    V call() throws Exception;}

它是一个有返回值的任务体，但是它和Runnable不同，Runnable是和Thread绑定的官方任务体，而Callable只是为达到实现获取任务返回值而衍生出来的一个任务体，它主要作为FutureTask类中的一个成员属性，充当真正被执行的任务体。qhh28资讯网——每日最新资讯28at.com

FutureTask源码分析

先看下FutureTask主要的属性和构造方法：qhh28资讯网——每日最新资讯28at.com

public class FutureTask<V> implements RunnableFuture<V> {    private volatile int state;    //等待执行状态 初始状态    private static final int NEW          = 0;    //执行完毕状态，但是结果还没有填充到outcome    private static final int COMPLETING   = 1;    //返回值填充outcome 正常结束任务状态    private static final int NORMAL       = 2;    //因异常而结束    private static final int EXCEPTIONAL  = 3;    //任务还未执行之前就调用了cancel(true)方法    private static final int CANCELLED    = 4;    //中断的中间状态    private static final int INTERRUPTING = 5;    //中断的状态    private static final int INTERRUPTED  = 6;    private Callable<V> callable;    private Object outcome;     private volatile Thread runner;    private volatile WaitNode waiters;        static final class WaitNode {        volatile Thread thread;        volatile WaitNode next;        WaitNode() {         thread = Thread.currentThread();         }    }        protected void done() { }         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);        this.state = NEW;           }

• state是状态，没到一个阶段都是不同的状态。
• outcome是存放返回值的，当任务执行完返回的值会赋值给outcome
• callable是真正的任务体，run方法在运行的时候实际上是运行callable对象的call方法。
• waiters是线程阻塞等待结果的时候存放的队列，它的类型是WaitNode，WaitNode里面有一个next属性，可见它是一个单向链表结构。
• runner是当前正在执行任务的线程
• done方法在FutureTask里面没有具体实现，它是任务处理完的一个后置方法，是留给子类用的。
• 构造方法一是接收一个Callable对象赋值给成员变量callable。- 构造方法二是接收一个Runnable对象和一个result值，同样是赋值给callable变量。

构造方法一很容易理解，构造方法二则是接收一个Runnable任务体，但是Runnable没有返回值，所以再接收一个result值作为默认的返回值，也就是无论任务体的任务执行的结果是什么，都以result值作为固定的返回值。qhh28资讯网——每日最新资讯28at.com

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

构造方法二中调用了Executors.callable()方法，这个方法就是将Runnable和result值封装为RunnableAdapter对象，RunnableAdapter实现了Callable，所以它也是一个Callable对象，所以可以赋值给成员变量callable.qhh28资讯网——每日最新资讯28at.com

接下来按照应用案例中的步骤跟一下源码，构造方法我们看了，接下来就是启动线程，启动线程就会调用任务体的run方法，我们从run方法开始跟进源码。qhh28资讯网——每日最新资讯28at.com

run方法源码分析

 public void run() {        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 {            int s = state;            if (s >= INTERRUPTING)                handlePossibleCancellationInterrupt(s);        }    }

1. 判断状态，只有当前状态为待执行状态，并且能利用cas将当前线程成功赋值给runner，进入下一步。
2. 如果成员变量callable不为空，执行任务体callable的call方法并得到返回值result。
3. 调用set(result)方法。

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

4. 将状态由NEW（待执行状态）改为COMPLETING(执行完成状态)。
5. 将返回值result赋值给成员变量outcome。
6. 将状态由改为COMPLETING（执行完成状态）NORMAL(返回值填充完毕状态)
7. 调用finishCompletion（）

  private void finishCompletion() {        for (WaitNode q; (q = 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;                     q = next;                }                break;            }        }        done();        callable = null;           }

8. 这个方法其实就是唤醒正在等待结果的线程，可能有多个线程在等待任务返回值，等待的线程都会被封装为一个WaitNode节点，多个节点以单向链表结构连接在一起，这个方法是从链表的头节点一个一个唤醒。

将所有的等待线程唤醒后，最后执行done方法，done方法在FutureTask没有被实现，所以也就相当于什么都不做，那么done存在的意义是什么呢？它存在的意义在于在任务处理的完毕后线程结束前做一些事情，是留给子类扩展用的。qhh28资讯网——每日最新资讯28at.com

再看futureTask.get()的源码分析

当前线程是等待任务结果的线程不同于上面执行任务的线程：qhh28资讯网——每日最新资讯28at.com

 public V get() throws InterruptedException, ExecutionException {        int s = state;        if (s <= COMPLETING)            s = awaitDone(false, 0L);        return report(s);    }

1. 如果此时状态是返回值填充完毕状态，那就进入report方法直接返回值即可，如果此时状态不是返回值填充完毕状态，就要进入awaitDone方法进行阻塞等待操作。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 (;;) {            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)                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);            }            else                LockSupport.park(this);        }    }

2. 先计算等待时长，结果要么是需要等待一定时长，要么是永久等待。
3. 进入循环进行一些力的判断处理。
4. 判断中断，如果是被中断直接出队并抛异常（外面可以通过捕获异常让下城跳出循环）。可见阻塞等待是可以被中断的。
5. 如果此时状态是大于等于返回值填充完毕状态直接返回此状态。
6. 如果此时状态为执行完毕状态，但是还没有到达返回值填充完毕状态，那就让出cpu稍微等待一下，因为这两个状态的间隔很短。
7. 如果上面的判断都不满足，那就为当前线程绑定WaitNode节点。
8. 如果绑定的WaitNode节点还没有入队，那就通过cas方式入队，就是替换头节点，也就是后进来的为头节点。
9. 如果指定了阻塞时间，此时要判断是否超时，如果超时就直接返回状态，如果没有超时，计算出所剩的时间，然后利用LockSupport.parkNanos阻塞。
10. 如果上面都不满足就利用LockSupport.park进入永久阻塞。

上面就是FutureTask主要的源码分析，其原理比较简单，如果是run方法中提供返回值的支持，还有一个方法runAndReset，它提供了任务循环执行的支持。qhh28资讯网——每日最新资讯28at.com

protected boolean runAndReset() {        if (state != NEW ||            !UNSAFE.compareAndSwapObject(this, runnerOffset,                                         null, Thread.currentThread()))            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                    ran = true;                } catch (Throwable ex) {                    setException(ex);                }            }        } finally {            s = state;            if (s >= INTERRUPTING)                handlePossibleCancellationInterrupt(s);        }        return ran && s == NEW;    }

这个代码很简单，如果状态为待执行，就会执行任务，不关心返回值，任务执行完不会更新状态，使得状态一直处于待执行状态，如果runAndReset方法被再次调用依然会再一次执行任务。ScheduledThreadPoolExecutor就利用了这个方法实现定时任务处理。qhh28资讯网——每日最新资讯28at.com

其他方法支持

上面说了FutureTask实现了Future接口，Future接口提供了对任务处理的能力qhh28资讯网——每日最新资讯28at.com

//获取任务结果 如果任务没有处理完就阻塞等待timeout时间V get(long timeout, TimeUnit unit);//获取任务结果 如果任务没有处理完就永久阻塞等待V get(); //任务执行完毕后执行的方法，用于子类扩展用boolean isDone();//任务是否被取消 true为已取消boolean isCancelled();//取消任务boolean cancel(boolean mayInterruptIfRunning);

cancel为取消任务，它有一个boolean类型的参数，true表示需要中断线程并且将状态改为INTERRUPTING，false表示只改状态为CANCELLED。qhh28资讯网——每日最新资讯28at.com

cancel方法的逻辑如下：qhh28资讯网——每日最新资讯28at.com

1. 只有处于待执行状态的任务才会被取消
2. 传参为false，状态由NEW改为CANCELLED
3. 传参为true，状态由NEW改为INTERRUPTING
4. 同时如果传参是true,则调用负责执行任务的那个线程的interrupt方法进行中断操作，最后将状态由INTERRUPTING改为INTERRUPTED
5. 唤醒所有正在等待任务结果的线程。
6. 最后执行done方法。

本文链接：http://www.28at.com/showinfo-26-14733-0.html并发编程：你真的了解FutureTask吗？

声明：本网页内容旨在传播知识，若有侵权等问题请及时与本网联系，我们将在第一时间删除处理。邮件：2376512515@qq.com

上一篇： 您有一篇Git 原理，请注意查收

下一篇： 微软未来两年将在澳大利亚投资32亿美元 扩大AI和云计算能力