【小家Java】Future与FutureTask的区别与联系

【小家java】java5新特性（简述十大新特性） 重要一跃
【小家java】java6新特性（简述十大新特性） 鸡肋升级
【小家java】java7新特性（简述八大新特性） 不温不火
【小家java】java8新特性（简述十大新特性） 饱受赞誉
【小家java】java9新特性（简述十大新特性） 褒贬不一
【小家java】java10新特性（简述十大新特性） 小步迭代
【小家java】java11新特性（简述八大新特性） 首个重磅LTS版本

Future模式简述
传统单线程环境下，调用函数是同步的，必须等待程序返回结果后，才可进行其余处理。 Futrue模式下，调用方式改成异步。
Futrue模式的核心在于：充分利用主函数中的等待时间，利用等待时间处理其余任务，充分利用计算机资源。
所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操做继续运行的方法。在 Java 语言中，简单的讲就是另启一个线程来完成调用中的部分计算，使调用继续运行或返回，而不须要等待计算结果。但调用者仍须要取线程的计算结果。

JDK5新增了Future接口，用于描述一个异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力，可是对于结果的获取倒是很不方便，只能经过阻塞或者轮询的方式获得任务的结果。阻塞的方式显然和咱们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，并且也不能及时地获得计算结果。

Future
Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果等操做。必要时能够经过get方法获取执行结果，该方法会阻塞直到任务返回结果。
Future类位于java.util.concurrent包下，它是一个接口：

public interface Future<V> {
    /**
     * 方法用来取消任务，若是取消任务成功则返回true，若是取消任务失败则返回false。
     *
     * @param mayInterruptIfRunning 表示是否容许取消正在执行却没有执行完毕的任务，若是设置true，则表示能够取消正在执行过程当中的任务。
     * @return 若是任务已经完成，则不管mayInterruptIfRunning为true仍是false，此方法确定返回false，即若是取消已经完成的任务会返回false；
     * 若是任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；
     * 若是任务尚未执行，则不管mayInterruptIfRunning为true仍是false，确定返回true。
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     * 方法表示任务是否被取消成功
     * @return 若是在任务正常完成前被取消成功，则返回 true
     */
    boolean isCancelled();

    /**
     * 方法表示任务是否已经完成
     * @return 若任务完成，则返回true
     */
    boolean isDone();

    /**
     * 方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回
     * @return 任务执行的结果值
     * @throws InterruptedException
     * @throws ExecutionException
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * 用来获取执行结果，若是在指定时间内，还没获取到结果，就直接返回null（并非抛出异常，须要注意）。
     * @param timeout 超时时间
     * @param unit 超时单位
     * @return
     * @throws InterruptedException
     * @throws ExecutionException
     * @throws TimeoutException
     */
    V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
从上面方法的注释能够看出，Futrue提供了三种功能：
1）判断任务是否完成；
2）可以中断任务；
3）可以获取任务执行结果。（最为经常使用的）

由于Future只是一个接口，因此是没法直接用来建立对象使用的，所以就有了下面的FutureTask（JDK8之前惟一实现类）。

FutureTask
public class FutureTask<V> implements RunnableFuture<V>
    public interface RunnableFuture<V> extends Runnable, Future<V>
1
2
由此看出FutureTask它既能够做为Runnable被线程执行，又能够做为Future获得Callable的返回值。
FutureTask提供了2个构造器：

    // 包装callable
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

    //把Runable转换成callable来处理(结果尽然让传进来，因此这个方法没啥用)
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
FutureTask实现了Runnable，所以它既能够经过Thread包装来直接执行，也能够提交给ExecuteService来执行。
FutureTask实现了Futrue能够直接经过get()函数获取执行结果，该函数会阻塞，直到结果返回。
举个栗子
直接使用Futrue来接收返回值：（结合callable）
    public static void main(String args[]) {
        Instant start = Instant.now();

        ExecutorService executor = Executors.newCachedThreadPool();
        //执行callable任务  拿到但绘制result
        Future<Integer> result = executor.submit(() -> {
            System.out.println("子线程在进行计算");
            Thread.sleep(3000);
            int sum = 0;
            for (int i = 0; i < 100; i++)
                sum += i;
            return sum;
        });
        Instant mid = Instant.now();
        System.out.println("Mid拿到Futrue结果对象result：" + Duration.between(start, mid).toMillis());

        try {
            System.out.println("task运行结果计算的总和为：" + result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executor.shutdown();

        Instant end = Instant.now();
        System.out.println("End拿到结果值：" + Duration.between(start, end).toMillis());
    }
输出：
子线程在进行计算
Mid拿到Futrue结果对象result：98
task运行结果计算的总和为：4950
End拿到结果值：3099
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
咱们很显然能够发现，mid的时间很短，主线程立刻向下执行了，可是end的时间就比较长了，所以get()拿结果属于阻塞方法。

FutureTask获取结果：(结合Callbale使用)
    public static void main(String args[]) {
        Instant start = Instant.now();

        ExecutorService executor = Executors.newCachedThreadPool();
        //使用FutureTask包装callbale任务，再交给线程池执行
        FutureTask<Integer> futureTask = new FutureTask<>(() -> {
            System.out.println("子线程在进行计算");
            Thread.sleep(3000);
            int sum = 0;
            for (int i = 0; i < 100; i++)
                sum += i;
            return sum;
        });
        //线程池执行任务 这个返回值不须要了，直接就在futureTask对象里面了
        executor.submit(futureTask);

        Instant mid = Instant.now();
        System.out.println("Mid拿到futureTask结果对象result：" + Duration.between(start, mid).toMillis());

        try {
            System.out.println("task运行结果计算的总和为：" + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executor.shutdown();

        Instant end = Instant.now();
        System.out.println("End拿到结果值：" + Duration.between(start, end).toMillis());
    }
输出：
子线程在进行计算
Mid拿到futureTask结果对象result：86
task运行结果计算的总和为：4950
End拿到结果值：3088
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
第二种方式（只是进行了简单包装而已）：

//第二种方式，注意这种方式和第一种方式效果是相似的，只不过一个使用的是ExecutorService，一个使用的是Thread
        FutureTask<Integer> futureTask = new FutureTask<>(() -> {
            System.out.println("子线程在进行计算");
            Thread.sleep(3000);
            int sum = 0;
            for (int i = 0; i < 100; i++)
                sum += i;
            return sum;
        });
        Thread thread = new Thread(futureTask);
        thread.start();
1
2
3
4
5
6
7
8
9
10
11
若是为了可取消性而使用 Future 但又不提供可用的结果，则能够声明 Future<?> 形式类型、并返回 null 做为底层任务的结果。

Callable和Futrue的区别：Callable用于产生结果，Future用于获取结果