一、FutureTask介绍

        Java创建线程的方式，一般常用的是Thread，Runnable，如果需要处理当前的任务有返回结果的话，需要使用Callable。Callable运行需要配合Future来使用。

        Future是一个接口，一般会使用FutureTask实现类去接收Callable任务的返回结果。FutureTask存在的问题就是同步非阻塞执行的任务，他不会主动通知你返回结果是什么。

二、FutureTask使用

        Callable是你要执行的任务。 FutureTask是存放任务返回结果的位置。

public static void main(String[] args) throws ExecutionException, InterruptedException {FutureTask<Integer> futureTask = new FutureTask<>(() -> {System.out.println("任务执行");Thread.sleep(2000);return 123+764;});Thread t = new Thread(futureTask);t.start();System.out.println("main线程启动了t线程处理任务");Integer result = futureTask.get();System.out.println(result);
}

三、FutureTask源码剖析 

        在分析FutureTask源码的时候我们先来看一下他里面的核心属性。

    /*** Possible state transitions:* NEW -> COMPLETING -> NORMAL  任务正常执行* NEW -> COMPLETING -> EXCEPTIONAL 任务执行过程中剖出了异常信息* NEW -> CANCELLED 任务被取消* NEW -> INTERRUPTING -> INTERRUPTED  */// 任务的执行状态private volatile int state;// 任务的初始化状态private static final int NEW          = 0;// Callable的结果正在封装给当前的FutureTaskprivate 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;// 存放对应的callable任务private Callable<V> callable;/** The result to return or exception to throw from get() */// 返回的结果，如果是异常则是保存的是异常信息private Object outcome; // non-volatile, protected by state reads/writes/** The thread running the callable; CASed during run() */// 当前运行任务的现车个private volatile Thread runner;/** Treiber stack of waiting threads */// 等待任务结果返回的挂起线程private volatile WaitNode waiters;

 3.1 run方法源码分析

         FutureTask本身也是Runnable接口，他本身自己重写了run方法，所以线程在运行的时候，其实就是运行的是FutureTask本身的run方法。

         接下来看下run源码。

public void run() {// 如果任务的状态不为new初始化状态并且cas改变runner为当前线程失败，则直接返回if (state != NEW ||!UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread()))return;try {// 获取任务对象Callable<V> c = callable;// dcl，继续判断任务的状态是否为newif (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 must be re-read after nulling runner to prevent// leaked interruptsint s = state;// 是否被中断了if (s >= INTERRUPTING)handlePossibleCancellationInterrupt(s);}
}// 设置返回值结果protected void set(V v) {// 开始封装值之前，CAS把state状态修改为COMPLETINGif (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {outcome = v;// 封装值成功，CAS把state状态值修改为NORMALUNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state// 这个作用就是唤醒等待的线程，具体源码下面分析finishCompletion();}}

3.2 get源码剖析 

         get方法获取返回结果，到挂起的位置。

    public V get() throws InterruptedException, ExecutionException {int s = state;// 说明当前任务状态还没有返回结果if (s <= COMPLETING)// 尝试挂起线程s = awaitDone(false, 0L);// 组装返回值return report(s);}// 设置返回结果
protected void set(V v) {
// 首先要将任务状态从NEW设置为COMPLETING
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {// 将返回结果设置给outcome。outcome = v;// 将状态修改为NORMAL，代表正常技术UNSAFE.putOrderedInt(this, stateOffset, NORMAL);// 一会再说，你猜猜~~~finishCompletion();
}
}// 这个是一个公共方法，get带时间等待的也是调用这个方法
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()) {// 把当前节点从waiters中移除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 yetThread.yield();// 第一次进来，封装node节点else if (q == null)q = new WaitNode();// 判断当前node节点是否加入waiters节点else if (!queued)// 头插法queued = UNSAFE.compareAndSwapObject(this, waitersOffset,q.next = waiters, q);// 是否有等待超时配置else if (timed) {// 判断当前的剩余等待时间nanos = deadline - System.nanoTime();if (nanos <= 0L) {// 移除node节点removeWaiter(q);// 返回任务状态return state;}// 挂起线程LockSupport.parkNanos(this, nanos);}else// 挂起线程LockSupport.park(this);}
}

        如果任务已经执行完成了，那么就由 finishCompletion唤醒线程。

 private void finishCompletion() {// assert state > COMPLETING;for (WaitNode q; (q = waiters) != null;) {// 拿到第一个节点，然后通过cas将其设置为nullif (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}

        拿到返回结果。

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

        总结： 问题1：FutureTask获取线程执行的结果前，主线程需要通过get方法一直阻塞等待子线程执行完call方法，才可以拿到返回结果。 问题2：如果不通过get去挂起线程，通过while循环，不停的判断任务的执行状态是否结束，结束后，再拿结果。如果任务长时间没执行完毕，CPU会一直调度查看任务状态的方法，会浪费CPU资源。 FutureTask是一个同步非阻塞处理任务的方式。 需要一个异步非阻塞处理任务的方式。CompletableFuture在一定程度上就提供了各种异步非阻塞的处理方案，并且提供响应式编程，代码编写上，效果更佳（更漂亮）