FutureTask 是什么？

本文内容如有错误、不足之处，欢迎技术爱好者们一同探讨，在本文下面讨论区留言，感谢。

简介

在 Java 中为了编程异步事件，我们使用 Thread 类和 Runnable 接口，它们可以开发并行应用程序。问题是在执行结束时不能返回值。因此，添加了 FutureTaks，Future 和 Callable 类，它们与以前的类具有大致相同的功能，但极大地促进了并行应用程序的开发。由于线程 Thread 只支持 Runnable 构造，于是有了 Future 可以根据 Callable 构建线程。由于 Future 只是一个接口，无法直接创建对象，因此有了 FutureTask 。 请参阅：

• Future：封装并行调用的类，可以取消任务的执行，确定执行是否已成功完成或出错，以及其他操作；
• FutureTask：这是 Future 接口的实现，将在并行调用中执行。
• Callable：用于实现并行执行的接口。它与 Runnable 接口非常相似，但是它不返回任何值，而 Callable 必须在执行结束时返回一个值。
• ExecutorService：用于在创建线程池，开始和取消管理并行执行的线程。

创建线程的3中方式 Thread、Runnable、Callable ，其中 Callable 是有返回结果的，这种特殊性在某种情况下非常有帮助，例如：需要知道每个线程计算金额的多少，那么需要返回结果并进行保存。

使用

概念：

1. FutureTask 实现 Future 接口和 RunnableFuture 接口，意味着可以将 FutureTask 用作 Runnable ，并且可以将其提交给 ExecutorService 进行执行。
2. 当调用一个 Future.submit() 来提交一个可调用或可运行的对象时，大多数时候 ExecutorService 将创建 FutureTask ，也可以手动创建它。
3. FutureTask 就像一个latch锁。
4. 由 FutureTask 表示的计算是通过 Callable 接口实现的。
5. 它实现了 Future 或 Callable 接口。
6. get() 方法的行为取决于任务的状态。如果任务未完成，则 get() 方法将等待或阻塞，直到任务完成。任务完成后，它将返回结果或引发 ExecutionException。

构造方法只有两个：

// Creates a FutureTask that will, upon running, execute the given Callable.
// 创建一个FutureTask将在运行时执行给定的Callable。
FutureTask(Callable<V> callable)

// Creates a FutureTask that will, upon running, execute the given Runnable, and arrange that get will return the given result on successful completion.
// 创建一个FutureTask将在运行时执行给定的Runnable，并在获得成功完成后返回给定结果result。
FutureTask(Runnable runnable, V result)

package test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Java 项目如何使用FutureTask例子
 */
public class FutureDemo {

    private static final ExecutorService threadpool = Executors.newFixedThreadPool(3);

    public static void main(String args[]) throws InterruptedException, ExecutionException {

        FactorialCalculator task = new FactorialCalculator(10);
        System.out.println("Submitting Task ...");

        Future future = threadpool.submit(task);

        System.out.println("Task is submitted");

        while (!future.isDone()) {
            System.out.println("Task is not completed yet....");
            Thread.sleep(1); //睡眠1秒
        }

        System.out.println("Task is completed, let's check result");
        long factorial = future.get();
        System.out.println("Factorial of 1000000 is : " + factorial);

        threadpool.shutdown();
    }

    private static class FactorialCalculator implements Callable {

        private final int number;

        public FactorialCalculator(int number) {
            this.number = number;
        }

        @Override
        public Long call() {
            long output = 0;
            try {
                output =  factorial(number);
            } catch (InterruptedException ex) {
                Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
            }

            return output;
        }

        private long factorial(int number) throws InterruptedException {
            if (number < 0) {
                throw new IllegalArgumentException("Number must be greater than zero");
            }
            long result = 1;
            while (number > 0) {
                Thread.sleep(1); // 等待1秒时间模拟计算
                result = result * number;
                number--;
            }
            return result;
        }
    }

}

输出结果：

Submitting Task ...
Task is submitted
Task is not completed yet....
Task is not completed yet....
Task is not completed yet....
Task is completed, let's check result
Factorial of 1000000 is : 3628800

原理

原理是将 Runnable 转换为 Callable 。

public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
}

采用适配器模式，调用 RunnableAdapter(task, result) 方法来适配

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;
        }
}

通过 Callable 的 call() 调用 Runnable 的 run()，把传入的 T result 作为 Callable 的返回结果；

总结

通过使用 FutureTask 类以及 Callable 和 Futere 接口，异步 Java 任务的编程变得更加容易，避免了实现此类应用程序以前所需的“麻烦”。

参考资料

How to use Future and FutureTask in Java Concurrency with Example（如何通过示例在Java并发中使用Future和FutureTask）

• https://javarevisited.blogspot.com/2015/01/how-to-use-future-and-futuretask-in-Java.html

Java FutureTask Example Program （Java FutureTask示例程序）

• https://www.journaldev.com/1650/java-futuretask-example-program

Class FutureTask（FutureTask类）

• https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/FutureTask.html

what is the advantage of using FutureTask over Callable?（与Callable相比，使用FutureTask有什么优势？）

• https://stackoverflow.com/questions/30976946/what-is-the-advantage-of-using-futuretask-over-callable

Processamento assíncrono em Java com Future e FutureTask（带有Future和FutureTask的异步Java处理）

• https://www.devmedia.com.br/processamento-assincrono-em-java-com-future-e-futuretask/33851