Future获取子线程的执行结果

最新推荐文章于 2024-07-09 14:31:18 发布
最新推荐文章于 2024-07-09 14:31:18 发布
阅读量5.6k 收藏 19
点赞数 4
分类专栏： JAVA多线程并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_35395498/article/details/118002490
版权

目录

 

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;
    }
}
法毅的博客
关注
专栏目录
使用Future及时获取多线程运行结果的实例分析
CodeShiftZ的博客
09-20 146
在上面的代码中，我们首先创建了一个单线程的线程池，使用Executors工具类的newSingleThreadExecutor()方法。然后，我们创建了一个FibonacciTask任务，并通过executorService.submit()方法将任务提交给线程池，返回一个Future对象。当我们需要获取任务的结果时，可以使用future.get()方法进行阻塞等待，直到任务执行完成并返回结果。通过使用Future，我们可以提交任务给线程池进行并发执行，并在需要时获取任务的结果。如有疑问，请随时提问。
Java 中 Future 的 get 方法超时会怎样？
明明如月的技术博客
06-14 5267
很多 Java 工程师在准备面试时，会刷很多八股文，线程和线程池这一块通常会准备线程的状态、线程的创建方式，Executors 里面的一些工厂方法和为什么不推荐使用这些工厂方法， 构造方法的一些参数和执行过程等。工作中，很多人会使用线程池的 方法 获取 Future 类型的返回值，然后使用 实现“最多等多久”的效果。但很多人对此的理解只停留在表面上，稍微问深一点点可能就懵逼了。比如， 超时之后，当前线程会怎样？线程池里执行对应任务的线程会有怎样的表现？如果你对这个问题没有很大的把握，说明你掌握的还不
java并发编程之Future.get() 一直阻塞
qingfeng2556的博客
11-15 482
担心调用量太多，允许丢弃部分结果，并行允许，定义线程池。自定义RejectedExecutionHandler，取消执行( ((FutureTask) r).cancel(true))，这样应该是最合适的。web调用时Executor.submit(),如果设置AbortPolicy时没有返回结果，只会抛出异常。转载自：https://blog.csdn.net/doctor_who2004/article/details/115647638。
Future：线程池提交了任务，怎么获取结果呢？
香农三定律的博客
11-13 1283
Future：线程池提交了任务，怎么获取结果呢？引言如何获取任务执行结果Future实战演练 引言 在上一篇文章中，我们仅仅介绍了 ThreadPoolExecutor 的 void execute(Runnable command) 方法，利用这个方法虽然可以提交任务，但是却没有办法获取任务的执行结果（execute() 方法没有返回值）。别急，本篇文章主角Future就是负责这部分的。 如何获取任务执行结果 Java 通过 ThreadPoolExecutor 提供的 3 个 submit() 方法和
Future使用详解
SRY12240419的博客
07-09 1096
/ 取消任务// 获取任务执行结果// 获取任务执行结果，带有超时时间限制// 判断任务是否已经取消// 判断任务是否已经结束。
Future - 获取子线程执行结果
Javaer`s blog
03-07 1399
1. 为什么要Future机制 对比常见的两种创建线程的方式，一种是直接继承Thread，另外一种就是实现Runnable接口，他们在执行完任务之后无法获取执行结果，从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果 Future模式的核心思想是能够让主线程将原来需要同步等待的这段时间用来做其他的事情。（因为可以异步获得执行结果，所以不用...
Future 模式详解
石头视角
01-27 1154
改模式的核心思想是异步调用。          在做应用开发时，有时会遇到一种场景：在完成某个主任务的同时，需要处理一些其它的子任务，为了加快响应速度，会将子任务放在另外的线程中执行。例如，搜索引擎在处理用户的查询请求时，不仅要从本地数据库查找匹配的结果，同时可能会向远程的广告服务器请求广告数据，最后将搜索结果和广告一起返回给用户。在这个例子中，主线程从本地查找搜索结果，同时启动子线程从远程
Future类详解
pengjianglilive的专栏
09-25 1759
1. Future的应用场景 在并发编程中，我们经常用到非阻塞的模型，在之前的多线程的三种实现中，不管是继承thread类还是实现runnable接口，都无法保证获取到之前的执行结果。通过实现Callback接口，并用Future可以来接收多线程的执行结果。 Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。 举个例子：比如去吃早点时，点了包子和凉菜，包子需要等3分钟，凉菜只需...
Java利用future及时获取多线程运行结果
08-29
getResult方法用于从future中获取线程结果，并打印结果。 在generate方法中，使用ExecutorService的submit方法来提交Callable任务，并将返回的Future对象添加到futureList中。然后，在getResult方法中，使用...
多线程执行完后主程序再执行（包括需要子线程返回结果）
04-07
`Future.get()`方法用于阻塞等待并获取子线程的计算结果。 在C#中，可以使用`Task`和`async/await`关键字来实现异步操作，获取子线程返回值： ```csharp Task<int> task1 = Task.Run(() => { // 子线程1的代码，...
获取线程的执行结果
共同进步，共同学习。
06-26 109
我们讲述了创建线程的 3 种方式，一种是直接继承 Thread，一种是实现 Runnable 接口，另外一种是实现 Callable 接口。前 2 种方式都有一个缺陷：在执行完任务之后无法获取执行结果。如果需要获取执行结果，就必须通过共享变量或者线程通信的方式来达到目的，这样使用起来就比较麻烦。Java 1.5 提供了 Callable、Future、FutureTask，它们可以在任务执行完后得到执行结果，今天我们就来详细的了解一下。
Future模式详解
weixin_43816711的博客
07-07 2224
Future模式是多线程开发中常见的设计模式，它的核心思想是异步调用。对于Future模式来说，它无法立即返回你需要的数据，但是它会返回一个契约，将来你可以凭借这个契约去获取你需要的信息。这是传统的同步方法，调用一段耗时的程序。当客户端发出call请求，这个请求需要很长的一段时间才会返回，客户端一直在等待直到数据返回随后再进行其他任务的处理。 而使用Future模式：从Data_Future对象可以看到虽然本身任然需要一段很长时间处理程序。但是服务程序并不等数据处理完成便立即返回客户端一个伪造的数据（如：
Java的Future机制详解
m0_62943934的博客
04-16 1600
一个java对象可以看成是一段内存，各个字段都得按照一定的顺序放在这段内存里，同时考虑到对齐要求，可能这些字段不是连续放置的，用这个UNSAFE.objectFieldOffset（）方法能准确地告诉你某个字段相对于对象的起始内存地址的字节偏移量，因为是相对偏移量，所以它其实跟某个具体对象又没什么太大关系，跟class的定义和虚拟机的内存模型的实现细节更相关。B图表达的是使用Future模式之后，我们主线程在invoke之后可以立即返回，去做其他的事情，回头再来看看刚才提交的invoke有没有结果。
异步编程学习之二：future详解
as4566的博客
08-03 648
大家好，我是小墨，be foolish,be hungry。本篇文章主要写redis的集群方案相关知识，欢迎大家多多斧正，如果觉得小墨我写得用心的话，可以点个赞啊。 对异步线程比较感兴趣，所以这章将通过讲解future使用方法，阅读futureTask源码，进行异步学习，后面会出一篇博客写异步进阶---completableFuture学习
【Java并发】线程池多线程调用 限定超时时间的future.get()串行阻塞式运行
锥栗的博客
06-05 7963
线程池多线程任务调用，串行阻塞式运行，虽然慢但稳妥要求单个线程运行时必须要有超时时间，超时则放弃运行下一个任务这里的实现仅能用，不完善Main.java 运行 运行结果：
Future的get方法实现
weixin_33695082的博客
04-23 2479
Future的get源码 /** * @throws CancellationException {@inheritDoc} */ public V get() throws InterruptedException, ExecutionException { int s = state; ...
Future 接口详细解读
Rambo's Blog
03-10 4294
文章目录一、Future 的应用场景二、Future 的类图结构三、Future 的接口方法四、Future 的应用示例 一、Future 的应用场景 在并发编程中，我们经常需要用非阻塞的模型，Java 默认多线程的三种实现中，继承 Thread 类和实现 Runnable 接口是异步并且主调函数是无法获取到返回值的。通过实现 Callback 接口，并用 Future 可以来接收多线程的执行结果 Future 接收一个可能还没有完成的异步任务的结果，针对这个结果可以添加 Callable 以便任务
future.get方法阻塞问题的解决，实现按照任务完成的先后顺序获取任务的结果
热门推荐
fourierr的博客
05-14 6万+
1、Future Future模式是多线程设计常用的一种设计模式。Future模式可以理解成：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。 Future提供了三种功能： 判断任务是否完成 能够中断任务 能够获取任务执行的结果 向线程池中提交任务的submit方法不是阻塞方法，而Future...
使用Future获取子线程发生的异常
最新发布
10-05
在Java中，`Future`接口用于异步计算的结果，它提供了一种处理后台任务的方式，而不需要立即等待结果。如果你想要获取子线程中抛出的异常，可以使用`Future.get()`方法，该方法会阻塞直到任务完成，并返回结果。如果在这个过程中任务抛出了异常，`get()`方法将捕获这个异常并作为其返回值。 这里是一个简单的例子： ```java ExecutorService executor = Executors.newSingleThreadExecutor(); Callable<String> callable = () -> { // 子线程执行的代码 try { return "Task Result"; } catch (Exception e) { throw new ExecutionException(e); // 如果有异常，包装成ExecutionException } }; Future<String> future = executor.submit(callable); try { String result = future.get(); // 获取结果 } catch (InterruptedException | ExecutionException e) { // 处理异常 if (e instanceof ExecutionException) { Exception cause = ((ExecutionException) e).getCause(); // 异常的实际原因 System.out.println("Got exception from task: " + cause.getMessage()); } else { System.out.println("Interrupted while waiting for task to complete."); } e.printStackTrace(); } executor.shutdown(); ``` 当`future.get()`抛出`ExecutionException`时，你可以通过检查`cause`属性来访问实际的异常。如果程序中断(`InterruptedException`)，则会捕获这个异常，而不是从任务获取的异常。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值