ThreadPoolExecutor 的 void execute(Runnable command) 方法，利用这个方法虽然可以提交任务，但是却没有办法获取任务的执行结果（execute() 方法没有返回值）。而很多场景下，我们又都是需要获取任务的执行结果的。那 ThreadPoolExecutor 是否提供了相关功能呢？必须的，这么重要的功能当然需要提供了。

如何获取任务执行结果

Java 通过 ThreadPoolExecutor 提供的 3 个 submit() 方法和 1 个 FutureTask 工具类来支持获得任务执行结果的需求。下面我们先来介绍这 3 个 submit() 方法，这 3 个方法的方法签名如下。

  1. // 提交 Runnable 任务
  2. Future<?> 
  3.   submit(Runnable task);
  4. // 提交 Callable 任务
  5. <T> Future<T> 
  6.   submit(Callable<T> task);
  7. // 提交 Runnable 任务及结果引用  
  8. <T> Future<T> 
  9.   submit(Runnable task, T result);

它们的返回值都是 Future 接口，Future 接口有 5 个方法，我都列在下面了，它们分别是取消任务的方法 cancel()、判断任务是否已取消的方法 isCancelled()、判断任务是否已结束的方法 isDone()以及2 个获得任务执行结果的 get() 和 get(timeout, unit)，其中最后一个 get(timeout, unit) 支持超时机制。通过 Future 接口的这 5 个方法你会发现，我们提交的任务不但能够获取任务执行结果，还可以取消任务。不过需要注意的是：这两个 get() 方法都是阻塞式的，如果被调用的时候，任务还没有执行完，那么调用 get() 方法的线程会阻塞，直到任务执行完才会被唤醒。

  1. // 取消任务
  2. boolean cancel(
  3.   boolean mayInterruptIfRunning);
  4. // 判断任务是否已取消  
  5. boolean isCancelled();
  6. // 判断任务是否已结束
  7. boolean isDone();
  8. // 获得任务执行结果
  9. get();
  10. // 获得任务执行结果，支持超时
  11. get(long timeout, TimeUnit unit);
  1. 这 3 个 submit() 方法之间的区别在于方法参数不同，下面我们简要介绍一下。
  1. 提交 Runnable 任务 submit(Runnable task) ：这个方法的参数是一个 Runnable 接口，Runnable 接口的 run() 方法是没有返回值的，所以 submit(Runnable task) 这个方法返回的 Future 仅可以用来断言任务已经结束了，类似于 Thread.join()。
  2. 提交 Callable 任务 submit(Callable task)：这个方法的参数是一个 Callable 接口，它只有一个 call() 方法，并且这个方法是有返回值的，所以这个方法返回的 Future 对象可以通过调用其 get() 方法来获取任务的执行结果。
  3. 提交 Runnable 任务及结果引用 submit(Runnable task, T result)：这个方法很有意思，假设这个方法返回的 Future 对象是 f，f.get() 的返回值就是传给 submit() 方法的参数 result。这个方法该怎么用呢？需要你注意的是 Runnable 接口的实现类 Task 声明了一个有参构造函数 Task(Result r) ，创建 Task 对象的时候传入了 result 对象，这样就能在类 Task 的 run() 方法中对 result 进行各种操作了。result 相当于主线程和子线程之间的桥梁，通过它主子线程可以共享数据。

下面我们再来介绍 FutureTask 工具类。前面我们提到的 Future 是一个接口，而 FutureTask 是一个实实在在的工具类，这个工具类有两个构造函数，它们的参数和前面介绍的 submit() 方法类似。

  1. FutureTask(Callable<V> callable);
  2. FutureTask(Runnable runnable, V result);

那如何使用 FutureTask 呢？其实很简单，FutureTask 实现了 Runnable 和 Future 接口，由于实现了 Runnable 接口，所以可以将 FutureTask 对象作为任务提交给 ThreadPoolExecutor 去执行，也可以直接被 Thread 执行；又因为实现了 Future 接口，所以也能用来获得任务的执行结果。下面的示例代码是将 FutureTask 对象提交给 ThreadPoolExecutor 去执行。

  1. // 创建 FutureTask
  2. FutureTask<Integer> futureTask
  3.   = new FutureTask<>(()-> 1+2);
  4. // 创建线程池
  5. ExecutorService es = 
  6.   Executors.newCachedThreadPool();
  7. // 提交 FutureTask 
  8. es.submit(futureTask);
  9. // 获取计算结果
  10. Integer result = futureTask.get();

利用 FutureTask 对象可以很容易获取子线程的执行结果。

实现最优的“烧水泡茶”程序

初中语文课文里有一篇著名数学家华罗庚先生的文章《统筹方法》，这篇文章里介绍了一个烧水泡茶的例子。
编写并发程序，首先要做的就是分工，所谓分工指的是如何高效地拆解任务并分配给线程。对于烧水泡茶这个程序，一种最优的分工方案可以是下图所示的这样：用两个线程 T1 和 T2 来完成烧水泡茶程序，T1 负责洗水壶、烧开水、泡茶这三道工序，T2 负责洗茶壶、洗茶杯、拿茶叶三道工序，其中 T1 在执行泡茶这道工序时需要等待 T2 完成拿茶叶的工序。对于 T1 的这个等待动作，你应该可以想出很多种办法，例如 Thread.join()、CountDownLatch，甚至阻塞队列都可以解决，不过今天我们用 Future 特性来实现。
下面的示例代码就是用 Future 特性来实现的。首先，我们创建了两个 FutureTask——ft1 和 ft2，ft1 完成洗水壶、烧开水、泡茶的任务，ft2 完成洗茶壶、洗茶杯、拿茶叶的任务；这里需要注意的是 ft1 这个任务在执行泡茶任务前，需要等待 ft2 把茶叶拿来，所以 ft1 内部需要引用 ft2，并在执行泡茶之前，调用 ft2 的 get() 方法实现等待。

  1. // 创建任务 T2 的 FutureTask
  2. FutureTask<String> ft2
  3.   = new FutureTask<>(new T2Task());
  4. // 创建任务 T1 的 FutureTask
  5. FutureTask<String> ft1
  6.   = new FutureTask<>(new T1Task(ft2));
  7. // 线程 T1 执行任务 ft1
  8. Thread T1 = new Thread(ft1);
  9. T1.start();
  10. // 线程 T2 执行任务 ft2
  11. Thread T2 = new Thread(ft2);
  12. T2.start();
  13. // 等待线程 T1 执行结果
  14. System.out.println(ft1.get());
  16. // T1Task 需要执行的任务：
  17. // 洗水壶、烧开水、泡茶
  18. class T1Task implements Callable<String>{
  19.   FutureTask<String> ft2;
  20.   // T1 任务需要 T2 任务的 FutureTask
  21.   T1Task(FutureTask<String> ft2){
  22.     this.ft2 = ft2;
  23.   }
  24.   @Override
  25.   String call() throws Exception {
  26.     System.out.println("T1: 洗水壶...");
  27.     TimeUnit.SECONDS.sleep(1);
  29.     System.out.println("T1: 烧开水...");
  30.     TimeUnit.SECONDS.sleep(15);
  31.     // 获取 T2 线程的茶叶  
  32.     String tf = ft2.get();
  33.     System.out.println("T1: 拿到茶叶:"+tf);
  35.     System.out.println("T1: 泡茶...");
  36.     return " 上茶:" + tf;
  37.   }
  38. }
  39. // T2Task 需要执行的任务:
  40. // 洗茶壶、洗茶杯、拿茶叶
  41. class T2Task implements Callable<String> {
  42.   @Override
  43.   String call() throws Exception {
  44.     System.out.println("T2: 洗茶壶...");
  45.     TimeUnit.SECONDS.sleep(1);
  47.     System.out.println("T2: 洗茶杯...");
  48.     TimeUnit.SECONDS.sleep(2);
  50.     System.out.println("T2: 拿茶叶...");
  51.     TimeUnit.SECONDS.sleep(1);
  52.     return " 龙井 ";
  53.   }
  54. }
  55. // 一次执行结果：
  56. T1: 洗水壶...
  57. T2: 洗茶壶...
  58. T1: 烧开水...
  59. T2: 洗茶杯...
  60. T2: 拿茶叶...
  61. T1: 拿到茶叶: 龙井
  62. T1: 泡茶...
  63. 上茶: 龙井
  1. <br />利用 Java 并发包提供的 Future 可以很容易获得异步任务的执行结果，无论异步任务是通过线程池 ThreadPoolExecutor 执行的，还是通过手工创建子线程来执行的。Future 可以类比为现实世界里的提货单，比如去蛋糕店订生日蛋糕，蛋糕店都是先给你一张提货单，你拿到提货单之后，没有必要一直在店里等着，可以先去干点其他事，比如看场电影；等看完电影后，基本上蛋糕也做好了，然后你就可以凭提货单领蛋糕了。<br />利用多线程可以快速将一些串行的任务并行化，从而提高性能；如果任务之间有依赖关系，比如当前任务依赖前一个任务的执行结果，这种问题基本上都可以用 Future 来解决。