与多线程相关的概念 — Callable、Future 和 FurtureTask
除了 Runnable 之外，Java 中还有 Callable、Future 和 FurtureTask 这几个与多线程相关的概念。与 Runnable 不同的是，这几个类型只能运用到线程池中，而 Runnable 既能运用在 Thread 中，又能运用在线程池中。
1. Callable
Callable 与 Runnable 的功能大致相似，不同的是 Callable 是一个泛型接口，它有一个泛型参数 V。该接口中有一个返回值（类型为 V）的 call 函数，而 Runnable 的 run 函数不能返回结果。
@FunctionalInterface
public interface Callable<V> {
// 返回V类型的结果
V call() throws Exception;
}
2. Future
Future 为线程池制定了一个可管理的任务标准。它提供了对 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作，分别对应 cancel、isDone、get、set 函数。get 方法会阻塞主线程，直到任务返回结果。Future 声明如下：
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
// 该任务是否已经取消
boolean isCancelled();
// 判断是否已经完成
boolean isDone();
// 获取结果，如果任务未完成，则等待，直到完成，因此该函数会阻塞
V get() throws InterruptedException, ExecutionException;
// 获取结果，如果任务未完成，则等待，直到 timeout 或者返回结果，
// 因此该函数会阻塞
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
3. FutureTask
Future 只是定义了一些规范接口，而 FutureTask 则是它的实现类。FutureTask 实现了 RunnableFuture<V>，而 RunnableFuture<V> 实现了 Runnable 和 Future<V> 这两个接口。因此 FutureTask 具备它们的能力。FutureTask 声明如下：
public class FutureTask<V> implements RunnableFuture<V> {
......
}
再看看 RunnableFuture 类定义：
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
就像 Thread 对 Runnable 进行包装一样，FutureTask 会对 Runnable 和 Callable<V> 进行包装，Runnable 与 Callable 由构造函数注入。
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
可以看到，如果注入的是 Runnable 则会被 Executors.callable() 函数转换成 Callable 类型，即 FutureTask 最终都是执行 Callable 类型的任务。该适配函数如下：
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
/**
* Runnable 适配器，将 Runnable 转换为 Callable
*/
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;
}
}
FutureTask 实现了 Runnable，因此，它可以通过 Thread 包装来直接执行，也可以提交给 ExecuteService 来执行。并且可以通过 get() 函数获取执行结果，该函数会阻塞主线程，直到结果返回。因此 FutureTask 既是 Future、Runnable、又是 Callable （如果是 Runnable 最终也会被转换为 Callable），它是三者的合体。
一个示例演示 Runnable、Callable、FutureTask
public class FutureDemo {
// 线程池
static ExecutorService sExecutorService = Executors.newSingleThreadExecutor();
// 向线程池中提交 Runnable 对象
public static void futureWithRunnable() throws ExecutionException, InterruptedException {
// 提交 Runnable，没有返回值，result 没有数据
Future<?> result = sExecutorService.submit(new Runnable() {
@Override
public void run() {
fibc(20);
}
});
System.out.println("future result for runnable: " + result.get());
}
// 提交 Callable 对象，有返回值
public static void futureWithCallable() throws ExecutionException, InterruptedException {
Future<Integer> result = sExecutorService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return fibc(20);
}
});
System.out.println("future result for callable: " + result.get());
}
// 提交 FutureTask 对象
public static void futureTask() throws ExecutionException, InterruptedException {
FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return fibc(20);
}
});
sExecutorService.submit(futureTask);
System.out.println("future result for futureTask: " + futureTask.get());
}
// 计算斐波那契数
private static int fibc(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
return fibc(n - 1) + fibc(n - 2);
}
}
public class Main {
public static void main(String[] args) {
// write your code here
try {
FutureDemo.futureWithRunnable();
FutureDemo.futureWithCallable();
FutureDemo.futureTask();
} catch (ExecutionException e1) {
e1.printStackTrace();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
输出结果：
future result for runnable: null
future result for callable: 6765
future result for futureTask: 6765
