public interface Runnable { public abstract void run();}Student implements RunnableThread xiaoming = new Thread(new Student());xiaoming.start();我们知道Runnable是一个接口，它用来承载的是具体的任务，交给Thread执行。
有这样一个场景：主线程执行一个任务（理解为调用一个方法）需要获取这个任务的返回值，然后再去执行另一个任务获取返回值，最后将两个返回值做其他处理，一般情况下耗时为两个任务的耗时和，如果想提高性能，可以用异步的方式，可以将任务一包装为Runnable，交给子线程执行，主线程执行第二个任务，这样就节省了一部分耗时，但是Runnable不支持返回值，所以行不通，而FutureTask就是解决这个问题的。
FutureTask的类图如下：
看图可以知道两个事：
所以说FutureTask就是一个实现了一套获取返回值机制的任务体，请注意它依然是任务体，自身不能执行任务，依然需要借助Thread执行。
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的入参。
代码中可以看到还有一个Callable类，这个其实也是任务体，它的源码如下：
public interface Callable<V> { V call() throws Exception;}它是一个有返回值的任务体，但是它和Runnable不同，Runnable是和Thread绑定的官方任务体，而Callable只是为达到实现获取任务返回值而衍生出来的一个任务体，它主要作为FutureTask类中的一个成员属性，充当真正被执行的任务体。
先看下FutureTask主要的属性和构造方法：
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; }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.
接下来按照应用案例中的步骤跟一下源码，构造方法我们看了，接下来就是启动线程，启动线程就会调用任务体的run方法，我们从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); } } protected void set(V v) { if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { outcome = v; UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state 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; }这个方法其实就是唤醒正在等待结果的线程，可能有多个线程在等待任务返回值，等待的线程都会被封装为一个WaitNode节点，多个节点以单向链表结构连接在一起，这个方法是从链表的头节点一个一个唤醒。
将所有的等待线程唤醒后，最后执行done方法，done方法在FutureTask没有被实现，所以也就相当于什么都不做，那么done存在的意义是什么呢？它存在的意义在于在任务处理的完毕后线程结束前做一些事情，是留给子类扩展用的。
当前线程是等待任务结果的线程不同于上面执行任务的线程：
public V get() throws InterruptedException, ExecutionException { int s = state; if (s <= COMPLETING) s = awaitDone(false, 0L); return report(s); }如果此时状态是返回值填充完毕状态，那就进入report方法直接返回值即可，如果此时状态不是返回值填充完毕状态，就要进入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); } }awaitDone方法是支持阻塞指定时长的。如果没有传入阻塞时长就是永久阻塞。
先计算等待时长，结果要么是需要等待一定时长，要么是永久等待。
进入循环进行一些力的判断处理。
判断中断，如果是被中断直接出队并抛异常（外面可以通过捕获异常让下城跳出循环）。可见阻塞等待是可以被中断的。
如果此时状态是大于等于返回值填充完毕状态直接返回此状态。
如果此时状态为执行完毕状态，但是还没有到达返回值填充完毕状态，那就让出cpu稍微等待一下，因为这两个状态的间隔很短。
如果上面的判断都不满足，那就为当前线程绑定WaitNode节点。
如果绑定的WaitNode节点还没有入队，那就通过cas方式入队，就是替换头节点，也就是后进来的为头节点。
如果指定了阻塞时间，此时要判断是否超时，如果超时就直接返回状态，如果没有超时，计算出所剩的时间，然后利用LockSupport.parkNanos阻塞。
如果上面都不满足就利用LockSupport.park进入永久阻塞。
上面就是FutureTask主要的源码分析，其原理比较简单，如果是run方法中提供返回值的支持，还有一个方法runAndReset，它提供了任务循环执行的支持。
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就利用了这个方法实现定时任务处理。
上面说了FutureTask实现了Future接口，Future接口提供了对任务处理的能力
//获取任务结果 如果任务没有处理完就阻塞等待timeout时间V get(long timeout, TimeUnit unit);//获取任务结果 如果任务没有处理完就永久阻塞等待V get(); //任务执行完毕后执行的方法，用于子类扩展用boolean isDone();//任务是否被取消 true为已取消boolean isCancelled();//取消任务boolean cancel(boolean mayInterruptIfRunning);cancel为取消任务，它有一个boolean类型的参数，true表示需要中断线程并且将状态改为INTERRUPTING，false表示只改状态为CANCELLED。
cancel方法的逻辑如下：
本文链接：http://www.28at.com/showinfo-26-13675-0.html面试中如何答好：FutureTask
声明：本网页内容旨在传播知识，若有侵权等问题请及时与本网联系，我们将在第一时间删除处理。邮件：2376512515@qq.com
上一篇： 使用Python处理大型CSV文件
下一篇： 基于ArkTS的应用入场动画
Copyright © 2016-2023 天津谷骐科技有限公司 版权所有 sitemap.xml
违法及侵权请联系：2376512515@qq.com 津ICP备18001702号
津公网安备 12010102000574号
