Future详解

最新推荐文章于 2024-04-16 07:56:17 发布
最新推荐文章于 2024-04-16 07:56:17 发布
阅读量2k 收藏 9
点赞数
分类专栏： JAVA多线程并发 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_35395498/article/details/121548789
版权

目录

1. Future 和 Callable

1. 1 Runnable的缺陷

1.2 Callable 接口

1.3  Future 和 Callable 关系

1.4 Future 的5个主要方法

1.4.1 get()方法：获取结果

1.4.2  get(long timeout,TimeUnit unit) 方法: 超时不获取

1.4.3 cancel 方法：取消任务的执行

1.4.4. isDone方法: 判断线程是否执行完毕

1.4.5. isCanaelled 方法: 判断是否被取消

2 Futrue代码演示

2.1 线程池的submit方法返回Future对象，get基本用法

2.2 Callable 的Lambda 表达式形式

2.3 多个任务，用Future数组来获取结果

2.4 抛出异常的情况和isDone

2.5 默认超时时间和取消

2.5 cancel 方法：取消任务的执行

3. FutureTask 获取结果

1. Future 和 Callable

1. 1 Runnable的缺陷

  • 不能返回一个返回值
  • 无法抛出一个 checked  exception

1.2 Callable 接口

  • 类似于Runnable，被其他线程执行的任务
  • 实现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;
}

1.3  Future 和 Callable 关系

  • 我们可以用 Future.get 获取 Callable接口返回的执行结果，还可以通过Futrue.isDone 来判断任务是否已经执行完了，以及取消这个任务，限时获取任务的结果等
  • 在call()未执行完毕之前，调用get()的线程(假定此时是主线程)，直到call()方法返回了结果后，此时future.get()才会得到该结果，然后主线程才会切换到runnable状态
  • 所以Future是一个存储器，它存储了call()这个任务的结果，然而这个任务的执行时间是无法提前确定的，因为这完全取决于call()方法执行的情况

1.4 Future 的5个主要方法

1.4.1 get()方法：获取结果

  1. get 方法的行为取决于Callable任务的状态，只有以下这 5 种情况：
  2. 任务正常完成：get 方法会立刻返回结果
  3. 任务尚未完成（任务还没开始或进行中）：get将阻塞并指导任务完成
  4. 任务执行过程中抛出Exception：get方法会排出ExecutionExecption:这里的抛出异常，是call()执行时产生的那个异常，看到这个异常类型是java.until.concurrent.ExecutionException.不论call()执行时抛出的异常类型是什么，最后get方法抛出的异常类型都是ExecutionException，任务被取消：get方法会抛出 CallcellationException
  5. 任务超时：get方法有一个重载方法，是传入一个延迟时间的，如果时间到了还没有获取结果，get方法就会排出TimeoutExceptionget

1.4.2  get(long timeout,TimeUnit unit) 方法: 超时不获取

  • 用get(long timeout,TimeUnit unit) 方法时，如果call()在规定时间内完成了任务，那么就会正常获取到返回值，如果再制定时间内没有计算出结果，那么就会抛出TimeoutException
  • 超时不获取，任务需取消

1.4.3 cancel 方法：取消任务的执行

1.4.4. isDone方法: 判断线程是否执行完毕

1.4.5. isCanaelled 方法: 判断是否被取消

2 Futrue代码演示

2.1 线程池的submit方法返回Future对象，get基本用法

首先，我们要给线程池提交我们的任务，提交时线程池会立刻返回给我们一个空的Future容器，当线程的任务一旦执行完毕，也就是当我们可以获取结果的时候，线程池便会把该结果填入到之前给我们的那个Future中去（而不是创建一个新的Future），我们此时便可以从该Future中获得任务执行的结果

/**
 * 描述：演示一个Future的使用方法
 */
public class OneFuture {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        Future<Integer> future = service.submit(new CallableTask());
        try {
            System.out.println(future.get());
        }catch (ExecutionException e){
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            service.shutdown();
        }
    }

    static class CallableTask implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return new Random().nextInt();
        }
    }
}

2.2 Callable 的Lambda 表达式形式

public class OneFutureLambda {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        Callable<Integer> callable = ()->{
            Thread.sleep(3000);
            return new Random().nextInt();
        };
        Future<Integer> future = service.submit(callable);
        try {
            System.out.println(future.get());
        }catch (ExecutionException e){
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            service.shutdown();
        }
    }

2.3 多个任务，用Future数组来获取结果


/**
 * 描述： 演示批量提交任务时，用List来批量接收结果
 */
public class MultiFutures {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        ArrayList<Future> futures = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            Future<Integer> future = service.submit(new CallableTask());
            futures.add(future);
        }

        for (int i = 0; i < 20; i++) {
            Future<Integer> future = futures.get(i);
            try {
                Integer integer = future.get();
                System.out.println(integer);
            }catch (Exception e){
                e.printStackTrace();
            }

        }

    }

    static class CallableTask implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return new Random().nextInt();
        }
    }
}

2.4 抛出异常的情况和isDone

/**
 * 描述： 演示 get 方法过程中抛出异常，for循环为了演示抛出异常的时机，并不是说一产生异常就抛出，
 *       直到我们get执行时，才会抛出
 */
public class GetException {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(20);
        Future<Integer> future = service.submit(new CallableTask());
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println(i);
                Thread.sleep(500);
            }
            System.out.println(future.isDone());
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("InterruptedException 异常");
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.out.println("ExecutionException 异常");
        }
    }

    static class CallableTask implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            throw new IllegalArgumentException("Callable 抛出异常");
        }
    }
}

2.5 默认超时时间和取消

/**
 * 描述： 演示get的超时方法，需要注意超时后处理，调用future.cancel(),
 * 演示cancel传入true和false的区别，代表是否中断正在执行的任务
 */
public class TimeOut {

    private static final Ad DEFAULT_AD = new Ad("无网络时候的默认广告");

    private static final ExecutorService exec = Executors.newFixedThreadPool(10);

    static class Ad{
        String name;
        public Ad(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Ad{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

    static class FetchAdTask implements Callable<Ad>{

        @Override
        public Ad call() throws Exception {
            try {
                Thread.sleep(3000);
            }catch (InterruptedException e){
                System.out.println("sleep 期间被中断了");
                return new Ad("被中断时候的默认广告");
            }
            return new Ad("挖掘机技术哪家强？");
        }
    }

    public void printAd(){
        Future<Ad> future = exec.submit(new FetchAdTask());
        Ad ad;
        try {
            ad = future.get(4000,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            ad = new Ad("被中断时候的默认广告");
        } catch (ExecutionException e) {
            ad = new Ad("异常时候的默认广告");
        } catch (TimeoutException e) {
            ad = new Ad("超时时候的默认广告");
            System.out.println("超时，为获取到广告");
            boolean cancel = future.cancel(false);
            System.out.println("cancel的结果："+cancel);
        }
        exec.shutdown();
        System.out.println(ad);
    }

    public static void main(String[] args) {
        TimeOut timeOut = new TimeOut();
        timeOut.printAd();
    }
}

2.5 cancel 方法：取消任务的执行

  1. 如果这个任务还没有开始执行，那么这种情况最简单，任务会被正常的取消，未来也不会被执行，方法返回true
  2. 如果任务已完成，或者已取消，那么cancel()方法会执行失败，方法返回false
  3. 如果这个任务已经开始执行了，那么取消这个方法将不会直接取消该任务，而是会根据我们填的参数mayInterruptIfRunning做判断

3. FutureTask 获取结果

把Callable实例当作参数，生成FutureTask的对象，然后把这个对象当作一个Runnable对象，用线程池或另起线程去执行这个Runnable对象，最后通过FutureTask 获取刚才执行的结果

/**
 * 描述： 演示FutureTask用法
 */
public class FutureTaskDemo {
    public static void main(String[] args) {
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<>(task);
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class Task implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("子线程正在计算");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}
法毅的博客
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Future获取子线程的执行结果
法毅的博客
06-19 4775
1. Runnable的缺陷 2.Callable 接口 3. Future 类 4.用法1: 线程池的submit方法会回Future对象，6分da
callable多线程future.get()方法
weixin_42440765的博客
07-19 4872
callable多线程future.get()方法能获取到当前线程的执行结果，但是会阻塞当前线程，即当前线程执行结束获取到结果后才会继续执行下一个线程，解决方法： 创建一个List数组存储funture，在所有线程执行以后遍历list获取结果。 int count = 0; List<Future<Integer>> res = new ArrayList<>(); ExecutorService executorService = Executors.newCached
Java的Future机制详解
最新发布
m0_62943934的博客
04-16 988
一个java对象可以看成是一段内存，各个字段都得按照一定的顺序放在这段内存里，同时考虑到对齐要求，可能这些字段不是连续放置的，用这个UNSAFE.objectFieldOffset（）方法能准确地告诉你某个字段相对于对象的起始内存地址的字节偏移量，因为是相对偏移量，所以它其实跟某个具体对象又没什么太大关系，跟class的定义和虚拟机的内存模型的实现细节更相关。B图表达的是使用Future模式之后，我们主线程在invoke之后可以立即返回，去做其他的事情，回头再来看看刚才提交的invoke有没有结果。
C++ 多线程（future篇）
weixin_42463482的博客
09-10 1445
在前面介绍了启动线程，以及多线程下如何保证共享资源的竞争访问、线程同步这些。但是thread类无法访问从线程直接返回的值，如果要想获取线程的的执行结果，一般都是依靠全局或static变量，或是以实参传递的变量，然后结合互斥锁、条件变量，等待的线程去查验所等待的条件。假如某个线程按计划只等待一次，只要条件成立一次，它就不再理会条件变量了，条件变量不一定就是这种同步模式的最佳选择， 如果我们等待的条件是判定某份数据是否可用，C++ 标准库提供的std::future类模板更适合这种场景。
JAVA并发编程工具篇--1.1理解Future获取线程执行结果
拽着尾巴的鱼儿的博客
01-06 1467
理解Future获取线程执行结果
java并发编程Future类详解
Koikoi12的博客
01-24 7306
作用和举例 future类的作用就是为了调用其他线程完成好后的结果，再返回到当前线程中，如上图举例： 小王自己是主线程，叫外卖等于使用future类，叫好外卖后小王就接着干自己的事去了，当外卖到了的时候，future.get获取，继续做接下来的事情 但要注意的是当还没获取外卖的时候，主线程中用餐这一步是卡住的 JDK中的Future实现 结构如下 常用方法： cancel()：如果等太久，你可以直接取消这个任务 isCancelled()：任务是不是已经取消了 isDone()：任务是不是已经完成了
Python模块future用法原理详解
09-18
主要介绍了Python模块future用法原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
C++11中std::future的具体使用方法
12-20
std::future所引用的共享状态不能与任何其它异步返回的对象共享(与std::shared_future相反)( std::future references shared state that is not shared with any other asynchronous return objects (as opposed to ...
java Future 接口使用方法详解
08-31
Java中的`Future`接口是Java并发编程的重要组成部分，它提供了对异步计算结果的访问和控制。`Future`接口在`java.util.concurrent`包中，主要用于处理由`ExecutorService`执行的任务。`Future`模式允许我们提交一个...
Spring Boot对Future模式的支持详解
08-26
主要给大家介绍了关于Spring Boot对Future模式的支持的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用spring boot具有一定的参考学习价值，需要的朋友们下面来一起看看吧
java Callable与Future的详解及实例
08-31
Callable 和 Future 是 Java 多线程编程中的两个关键接口，它们在 Java 5 及以上版本引入，以增强并发处理的能力。Callable 接口类似 Runnable，但提供了更丰富的功能，而 Future 对象则用于管理和控制异步计算的...
c++11新特性之future
whl0071的专栏
08-09 2982
c++11新特性之future
Java中 Future类中 get 的使用
weixin_34388207的博客
05-24 3549
2019独角兽企业重金招聘Python工程师标准>>> ...
高级并发编程学习-callable与Future的使用
leixingbang的专栏
01-11 2908
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等
Int 和 Integer
Future_LL的博客
03-10 227
从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换.Java为每个原始类型提供了包装类型： - 原始类型：boolean，char ，byte，short，int，long，float，double-包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double Int和Integer的区别： Integer 是int...
Callable，Future 多线程并发获取结果
xsh_cloudy的博客
03-05 708
点击跳转到我的个人网站https://www.xiaoshenghao.cn 1.futrue 接口，callable接口 Callable接口代表一段可以调用并返回结果的代码;Future接口表示异步任务，是还没有完成的任务给出的未来结果。所以说Callable用于产生结果，Future用于获取结果。 Callable接口使用泛型去定义它的返回类型。Executors类提供了一些有用的...
【多线程编程】Future接口获取线程执行结果数据
qq_38377525的博客
06-11 1066
【多线程编程】Future接口获取线程执行结果数据
C++11中std::future的使用
热门推荐
网络资源是无限的
01-30 2万+
C++11中的std::future是一个模板类。std::future提供了一种用于访问异步操作结果的机制。std::future所引用的共享状态不能与任何其它异步返回的对象共享(与std::shared_future相反)( std::future references shared state that is not shared with any other asynchronous re...
r 语言future.apply包中函数详解
05-30
R语言中的future.apply包提供了一些函数来实现并行计算，下面是一些常用函数的详解： 1. future_lapply(): 对列表中的每个元素应用一个函数，返回一个列表。 2. future_sapply(): 对列表中的每个元素应用一个函数，返回一个向量或矩阵。 3. future_vapply(): 对列表中的每个元素应用一个函数，返回一个向量或矩阵，需要指定返回结果的类型。 4. future_mapply(): 对多个列表中的对应元素应用一个函数，返回一个列表。 5. future_apply(): 对矩阵或数组的每一行或列应用一个函数，返回一个向量或矩阵。 6. future_eapply(): 对环境中的每个元素应用一个函数，返回一个列表。 7. future_rapply(): 对列表或矩阵的每个元素应用一个函数，返回一个列表或矩阵，可以递归地应用到嵌套列表或矩阵中的每个元素。 这些函数都有一个相似的参数结构，其中主要的参数包括： 1. X: 应用函数的列表、矩阵或数组。 2. FUN: 应用的函数。 3. ...: FUN函数的其他参数。 4. future.seed: 随机数种子。 5. future.scheduling: 任务调度策略，包括顺序执行（sequential）、并行执行（multisession）和分布式执行（multicore）。 6. future.lazy: 是否惰性计算。 使用这些函数可以将串行的计算转换成并行的计算，进而提高运行效率。但是需要注意的是，过多的并行计算会增加系统开销，有可能反而降低计算速度，因此需要根据实际情况进行权衡。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值