以下为执行异常时赋值逻辑，直接将Throwable对象赋值到outcome属性上。

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

无论是正常执行还是异常执行，最终都会调用一个finishCompletion方法，用来做工作的收尾工作。

2.4 get方法介绍

Future的get方法有两个重载的方法，一个是get()获取结果，一个是get(long, TimeUnit)带有超时时间的获取结果，我们看下FutureTask中的这两个方法是如何实现的。

// 不带有超时时间，一直阻塞直到获取结果
public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            // 等待结果完成，带有超时的get方法也是调用的awaitDone方法
            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;
        // 如果任务未中断，调用awaitDone方法等待任务结果
        if (s <= COMPLETING &&
            (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
            throw new TimeoutException();
        // 返回结果
        return report(s);
    }

我们主要看下awaitDone方法的执行逻辑。此方法会通过for循环的方式一直阻塞等待任务执行完成。如果带有超时时间，则超过截止时间后会直接返回。

// timed：是否需要超时获取
// nanos：超时时间单位纳秒
private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        // 此方法会一直for循环判断任务状态是否已经完成，是Future.get阻塞的原因
        for (;;) {
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }

            int s = state;
            // 任务状态大于COMPLETING，则表明任务结束，直接返回
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING) // cannot time out yet
                // Thread.yield() 方法，使当前线程由执行状态，变成为就绪状态，让出cpu时间，在下一个线程执行时候，此线程有可能被执行，也有可能没有被执行。
                // COMPLETING状态为瞬时状态，任务执行完成，要么是正常结束，要么异常结束，后续会被置为NORMAL或者EXCEPTIONAL
                Thread.yield();
            else if (q == null)
                // 每调用一次get方法，都会创建一个WaitNode等待节点
                q = new WaitNode();
            else if (!queued)
                // 将该等待节点添加到链表结构waiters中，q.next = waiters 即在waiters的头部插入
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            // 如果方法带有超时判断，则判断当前时间是否已经超过了截止时间，如果超过了及截止日期，则退出循环直接返回当前状态，此时任务状态一定是NEW
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            else
                LockSupport.park(this);
        }
    }

我们在看下report方法，在调用get方法时是如何返回结果的。

这里首先获取outcome的值，并判断任务是否已经执行完成，如果执行完成，则将outcome对象强转成泛型指定的类型；如果任务被取消了，则抛出一个CancellationException异常；如果都不是，则说明任务在执行过程中发生了异常，此时任务状态位EXCEPTIONAL，此时的outcome即为Throwable对象，所以将outcome强转为Throwable并抛出异常。

由此可以知道，我们将一个FutureTask任务submit到线程池中执行的时候，如果发生了异常，是会在调用get方法的时候抛出的。

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

2.5 cancel方法介绍

cancel方法用于取消正在运行的任务，如果任务取消成功，则返回TRUE，如果取消失败则返回FALSE。