我们都知道Callable接口作为任务给线程池来执行，可以通过Future对象来获取返回值，他们背后的实现原理是什么？通过总结背后的实现原理有助于我们深入的理解相关技术，做到触类旁通和举一反三。
文章目录
一、使用示例
先通过一个简单示例来了解Callable如何使用：
public class FutureTaskTest {
public static void main(String[] args) {
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
Future<Integer> result = executor.submit(task);
executor.shutdown();
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
System.out.println("主线程在执行任务");
try {
System.out.println("task运行结果"+result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("所有任务执行完毕");
}
static class Task implements Callable<Integer> {
public Integer call() throws Exception {
System.out.println("子线程在进行计算");
Thread.sleep(30000);
int sum = 0;
for(int i=0;i<100;i++)
sum += i;
return sum;
}
}
}
二、工作流程分析
通过调试代码可知Callable工作流程如下：
1.submit方法接受Callable接口,首先包裹成功FutureTask对象，并作为返回值返回。
2.调用ThreadPoolExecutor.execute方法
2.1 线程池中的工作线程最终执行后会调用FutureTask的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 {
// 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 interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
2.2 run方法主要是执行Callable接口，并把返回值写入到FutureTask的outcome属性中,并调用LockSupport.unpack方法
3.主线程继续执行。
4.主线程调用FutureTask.get方法获取返回值。
4.1 如果FutureTask计算没有完成，那么需要等待完成,这个时候会调用LockSupport.pack方法阻塞线程
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);
}
}
三、工作流程归纳
Callable工作流程归纳：
1.submit方法接受Callable接口,首先包裹成功futruetask对象，并作为返回值返回。
2.FutureTask实现了Runnable接口和Future接口。由于实现了Runnable接口（runnable实现方法中会调用Callable接口），可以给线程池执行；future接口管理执行过程，比方说取消，阻塞获取执行结果，判断是否执行完成，是否取消。
所以Callable接口实现的核心是FutureTask，那么FutureTask类的设计原理是什么呢？
四、FutureTask类的设计原理
要理解一个类的设计原理，首先要知道这个类为我们提供了什么功能。通过上面的流程归纳2我们知道，FutureTask给我们提供两个功能？
- 作为一个任务，可以给线程池来执行。
- 能够任务做一些控制：比方说取消，阻塞获取执行结果，判断是否执行完成，是否取消
这里我们重点分析下阻塞获取执行结果必要性和实现思路。
必要性：
如果我们一个后端接口有一些耗时（CPU/IO）的操作需要执行，我们首先能想到的方法是把这些操作并行处理。任务并行处理之后，就有一个线程同步的问题：主线程执行完其他操作后，可能需要获取其他线程的执行结果。如果并行操作还没有完成，主线程需要等待并行操作完成后，才能拿到最终结果。所以Future.get方法是有必要的。
实现思路：
- FutureTask依赖一个Callable接口，这个接口表示具体需要执行的任务。
- 实现Runnable接口，这样就可以交给线程池来实现。
- Runnable接口实现方法中主要做的事情是调用Callable接口完成计算任务，并把结果集返回一个变量中，并更新任务状态。
- FutureTask.get方法，根据任务状态来判断任务是否完成，如果没有完成需要等待任务的完成，完成挂起线程。
- Runnable接口中的任务完成后，会唤醒主线程。
- 主线程继续执行，能获取结果。