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

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

public class FutureTask<V> implements RunnableFuture<V>
  public interface RunnableFuture<V> extends Runnable, Future<V>

  // 包装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
    }

    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

    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

//第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是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();