Future完成 java java中的future类

目录

一、Future的类图结构

二、Future的主要方法

三、Future的三种状态

四、Future，未来！

---

在之前学习线程的时候，老师教了三种创建线程的方法，其中一个就是通过 FutureTask

一、Future的类图结构

RunnableFuture：同时继承Future接口和Runnable接口，在成功执行run（）方法后，可以通过Future访问执行结果。这个接口都实现类是FutureTask,一个可取消的异步计算，这个类提供了Future的基本实现。计算的结果只能在计算已经完成的情况下恢复。如果计算没有完成，get方法会阻塞，一旦计算完成，这个计算将不能被重启和取消，除非调用runAndReset方法。

SchedualFuture：表示一个延时的行为可以被取消。通常一个安排好的future是定时任务SchedualedExecutorService的结果。

CompleteFuture：一个Future类是显示的完成，而且能被用作一个完成等级，通过它的完成触发支持的依赖函数和行为。当两个或多个线程要执行完成或取消操作时，只有一个能够成功。

ForkJoinTask：基于任务的抽象类，可以通过ForkJoinPool来执行。一个ForkJoinTask是类似于线程实体，但是相对于线程实体是轻量级的。大量的任务和子任务会被ForkJoinPool池中的真实线程挂起来，以某些使用限制为代价。详情见：javascript:void(0)

二、Future的主要方法

get()：可以当任务结束后返回一个结果，如果调用时，工作还没有结束，则会阻塞线程，直到任务执行完毕

get(long timeout,TimeUnit unit)：等待timeout的时间再返回结果

cancel(boolean mayInterruptIfRunning)：可以用来停止一个任务，如果任务可以停止（通过mayInterruptIfRunning来进行判断），则可以返回true,如果任务已经完成或者已经停止，或者这个任务无法停止，则会返回false.

isDone()：判断当前方法是否完成

isCancel()：判断当前方法是否取消

三、Future的三种状态

未启动状态：FutureTask.run方法处于未执行之前，FutureTask处于未启动

已经启动：FutureTask.run()方法被执行的过程中，FutureTask处于启动状态

已完成：FutureTask.run执行完；或者FutureTask.cancell()；或者执行run()方法抛出异常而结束。

示意图：

当FutureTask处于未启动或者启动状态时，执行FutureTask.get()方法将导致调用线程阻塞，当FutureTask处于已经完成状态时，执行FutureTask.get()方法将导致调用线程立即返回结果或者抛出异常。

当FutureTask处于未启动状态时，执行FutureTask.cancel()方法将导致此任务永远不会执行；

当FutureTask处于已启动状态时，执行FutureTask.cancel(true)方法将以中断此任务线程的方式来试图停止任务；

当FutureTask处于已启动状态时，执行FutureTask.cancel(false)方法将不会对正在执行此任务 的线程产生影响(让正在执行的任务运行完成)；

当FutureTask处于已完成的状态时，执行FutureTaskcancel(...)方法将返回false。
 

四、Future，未来！

举个例子：做饭需要厨具和食材，假如我们现在没有厨具和食材。这时我们决定去网上买厨具明天才能到，然后去超市买食材。在厨具还没有送到之前，我们就可以去超市买菜。

我们可以把网购厨具看成是主线程，子线程是去买菜，子线程执行的结果是需要返回值的，分别返回厨具对象和食材对象，但是run方法时没有返回值的。此时未来的概念就体现出来了~

下面我们用代码来显示这个过程：

1、"死等"模式

public class CookTask {
    //做饭
    static void cook(Pan pan, Food food){}    
    // 厨具类
    static class Pan{}
    // 食材类
    static class Food{}
    
    // 网购厨具线程
    static class OnlineShopping extends Thread {
        private Pan pan;
        @Override
        public void run() {
            System.out.println("第一步：下单");
            System.out.println("第一步：等待送货");
            try {
                Thread.sleep(5000);  // 模拟送货时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("第一步：快递送到");
            pan = new Pan();
        }
        
    }
    
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        // 第一步 网购厨具
        OnlineShopping thread = new OnlineShopping();
        thread.start();
        thread.join();  // 等待厨具送到
        // 第二步 去超市购买食材
        Thread.sleep(2000);  // 模拟购买食材时间
        Food food = new Food();
        System.out.println("第二步：食材到位");
        // 第三步 用厨具烹饪食材
        System.out.println("第三步：开始做饭");
        cook(thread.pan, food);
        System.out.println("总共用时" + (System.currentTimeMillis() - startTime) + "ms");
    }
}

运行结果：

可见在厨具送到期间，调用join方法阻塞主线程，也就是说我们不能干任何事。此时多线程就是去了意义。run方法不执行完，属性pan就不能被赋值，没有厨具做不了饭。

Java现在的多线程机制，核心方法run是没有返回值的；如果要保存run方法里面的计算结果，必须等待run方法计算完，无论计算过程多么耗时。为了提高效率，需要在子线程run方法计算的期间在主线程里面继续异步执行。、

2、”未来“模式

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CookTask {
    //  用厨具烹饪食材
    static void cook(Pan pan,Food food) {}
    // 厨具类
    static class Pan{}
    // 食材类
    static class Food{}
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long startTime = System.currentTimeMillis();
        // 第一步 网购厨具
        Callable<Pan> onlineShopping = new Callable<Pan>() {
            @Override
            public Pan call() throws Exception {
                System.out.println("第一步：下单");
                System.out.println("第一步：等待送货");
                Thread.sleep(5000);  // 模拟送货时间
                System.out.println("第一步：快递送到");
                return new Pan();
            }
            
        };
        
        FutureTask<Pan> task = new FutureTask<Pan>(onlineShopping);
        new Thread(task).start();
        // 第二步 去超市买食材
        Thread.sleep(2000);  // 模拟购买食材时间
        Food food = new Food();
        System.out.println("第二步：食材到位");
        // 第三步 用厨具烹饪食材
        if (!task.isDone()) {  // 联系快递员，询问是否到货
            System.out.println("第三步：厨具还没到(可以调用cancel方法取消订单)");
        }
        Pan pan = task.get();
        System.out.println("第三步：厨具到位，开始做饭");
        cook(pan, food);
        System.out.println("总共用时" + (System.currentTimeMillis() - startTime) + "ms");
    }
}

运行结果：

可见，在快递员送厨具的期间，我们去超市买食材了；而且我们可以知道厨具到没到，甚至可以在厨具没到的时候，取消订单。

接下来，我们来分析一下上面的代码

1、将较为耗时(网购餐具)的逻辑封装到了一个Callable的call方法里

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

 Callable接口可以看作是Runnable接口的补充，call方法带有返回值，并且可以抛出异常

2、把Callable实例当作参数，生成一个FutureTask的对象，然后把这个对象当作一个Runnable，作为参数另起线程。

public class FutureTask<V> implements RunnableFuture<V>

public interface RunnableFuture<V> extends Runnable, Future<V>

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

这个继承体系中的核心接口是Future。Future的核心思想是：主线程需要等待一个方法的返回，计算过程可能非常耗时显然死等是不明智。可以在调用f的时候，立马返回一个Future，可以通过Future这个数据结构去控制方法f的计算过程。

这里的控制包括：

get方法：获取计算结果（如果还没计算完，也是必须等待的）

cancel方法：还没计算完，可以取消计算过程

isDone方法：判断是否计算完

isCancelled方法：判断计算是否被取消

3、当买完菜，也就是程序执行了2秒的时候，我们就调用了get方法来获取一个"未来"的厨具，但其实此时厨具还没有送到(isdone()方法返回false)，所以还是会再等3秒。对比第一段代码的执行结果，这里我们节省了2秒。这是因为在快递员送货期间，我们去超市购买食材，这两件事在同一时间段内异步执行。

 

---