1.1 FutureTask介绍

FutureTask是一个可以取消异步任务的类。FutureTask对Future做的一个基本实现。可以调用方法区开始和取消一个任务。
一般是配合Callable去使用。
异步任务启动之后，可以获取一个绑定当前异步任务的FutureTask。
可以基于FutureTask的方法去取消任务，查看任务是否结果，以及获取任务的返回结果。
FutureTask内部的整体结构中，实现了RunnableFuture的接口，这个接口又继承了Runnable, Future这个两个接口。所以FutureTask也可以作为任务直接交给线程池去处理。

1.2 FutureTask应用

大方向是FutureTask对任务的控制：

● 任务执行过程中状态的控制
● 任务执行完毕后，返回结果的获取

FutureTask的任务在执行run方法后，是无法被再次运行，需要使用runAndReset方法才可以。

public static void main(String[] args) throws InterruptedException {
// 构建FutureTask，基于泛型执行返回结果类型
// 在有参构造中，声明Callable或者Runnable指定任务
FutureTask<String> futureTask = new FutureTask<>(() -> {
System.out.println("任务开始执行……");
Thread.sleep(2000);
System.out.println("任务执行完毕……");
return "OK!";
});
// 构建线程池
ExecutorService service = Executors.newFixedThreadPool(10);
// 线程池执行任务
service.execute(futureTask);// futureTask提供了run方法，一般不会自己去调用run方法，让线程池去执行任务，由线程池去执行run方法
// run方法在执行时，是有任务状态的。任务已经执行了，再次调用run方法无效的。
// 如果希望任务可以反复被执行，需要去调用runAndReset方法
// futureTask.run();
// 对返回结果的获取，类似阻塞队列的poll方法
// 如果在指定时间内，没有拿到方法的返回结果，直接扔TimeoutException
// try {
// String s = futureTask.get(3000, TimeUnit.MILLISECONDS);
// System.out.println("返回结果：" + s);
// } catch (Exception e) {
// System.out.println("异常返回：" + e.getMessage());
// e.printStackTrace();
// }
// 对返回结果的获取，类似阻塞队列的take方法，死等结果
// try {
// String s = futureTask.get();
// System.out.println("任务结果：" + s);
// } catch (ExecutionException e) {
// e.printStackTrace();
// }
// 对任务状态的控制
// System.out.println("任务结束了么？：" + futureTask.isDone());
// Thread.sleep(1000);
// System.out.println("任务结束了么？：" + futureTask.isDone());
// Thread.sleep(1000);
// System.out.println("任务结束了么？：" + futureTask.isDone());
}

1.3 FutureTask源码分析

看FutureTask的源码，要从几个方向去看：
● 先查看FutureTask中提供的一些状态
● 在查看任务的执行过程

1.3.1 FutureTask中的核心属性

清楚任务的流转流转状态是怎样的，其次对于核心属性要追到是干嘛的。

/**
FutureTask的核心属性
FutureTask任务的状态流转
* NEW -> COMPLETING -> NORMAL 任务正常执行，并且返回结果也正常返回
* NEW -> COMPLETING -> EXCEPTIONAL 任务正常执行，但是结果是异常
* NEW -> CANCELLED 任务被取消
* NEW -> INTERRUPTING -> INTERRUPTED 任务被中断
*/
// 记录任务的状态
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;
/** 需要执行任务，会被赋值到这个属性 */
private Callable<V> callable;
/** 任务的任务结果要存储在这几个属性中 */
private Object outcome; // non-volatile, protected by state reads/writes
/** 执行任务的线程 */
private volatile Thread runner;
/** 等待返回结果的线程Node对象， */
private volatile WaitNode waiters;
static final class WaitNode {
volatile Thread thread;
volatile WaitNode next;
WaitNode() { thread = Thread.currentThread(); }
}

1.3.2 FutureTask的run方法

任务执行前的一些判断，以及调用任务封装结果的方式，还有最后的一些后续处理

// 当线程池执行FutureTask任务时，会调用的方法
public void run() {
// 如果当前任务状态不是NEW，直接return告辞
if (state != NEW ||
// 如果状态正确是NEW，这边需要基于CAS将runner属性设置为当前线程
// 如果CAS失败，直接return告辞
!UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
return;
try {
// 将要执行的任务拿到
Callable<V> c = callable;
// 健壮性判断，保证任务不是null
// 再次判断任务的状态是NEW（DCL）
if (c != null && state == NEW) {
// 执行任务
// result：任务的返回结果
// ran：如果为true，任务正常结束。 如果为false，任务异常结束。
V result;
boolean ran;
try {
// 执行任务
result = c.call();
// 正常结果，ran设置为true
ran = true;
} catch (Throwable ex) {
// 如果任务执行期间出了异常// 返回结果置位null
result = null;
// ran设置为false
ran = false;
// 封装异常结果
setException(ex);
}
if (ran)
// 封装正常结果
set(result);
}
} finally {
// 将执行任务的线程置位null
runner = null;
// 拿到任务的状态
int s = state;
// 如果状态大于等于INTERRUPTING
if (s >= INTERRUPTING)
// 进来代表任务中断，做一些后续处理
handlePossibleCancellationInterrupt(s);
}
}