与多线程相关的概念 — 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