CompletableFuture异步编程

已于 2022-11-04 23:14:25 修改
阅读量885 收藏 2
点赞数 2
分类专栏： Java 文章标签： java
于 2022-11-04 23:13:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54429571/article/details/127697841
版权

Future和Callable接口

  • Future接口定义了操作异步任务执行一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。
  • Callable接口中定义了需要有返回的任务需要实现的方法
  • join和get对比，get会抛出异常，join不需要
  • 示例代码如下
/**
 * FutureTask & Callable
 * 异步任务执行
 */
public class FutureTaskTest {

    public static void main(String[] args) {
        FutureTask<String> task = new FutureTask<>(new MyThread());
        //task.run(); 执行任务线程
        Thread t1 = new Thread(task, "t1");
        t1.start();
        try {
            String res = task.get(); //获取返回结果，容易导致程序执行阻塞
            System.out.println(res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class MyThread implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println("come in call()...");
        return "hello callable";
    }
}

CompletableFuture类

这里是引用
在这里插入图片描述
在这里插入图片描述

核心的四个静态方法

//runAsync 无返回值
public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable,Executor executor)

//supplyAsync 有返回值  
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,Executor executor)
//没有指定Executor的方法，
//直接使用默认的ForkJoinPool.commonPool() 作为它的线程池执行异步代码。
runAsync无返回值
/**
 * CompletableFuture
 * 静态方法 runAsync 无返回值
 */
public class CompletableFutureTest01 {

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(1); //创建线程池

        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
            System.out.println("run task...");
            System.out.println(Thread.currentThread().getName());
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },threadPool); //默认有线程池，也可自定义指定

        try {
            System.out.println(completableFuture.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        threadPool.shutdown(); //关闭线程池
    }
}
supplyAsync有返回值
/**
 * CompletableFuture
 * 静态方法 supplyAsync 有返回值
 */
public class CompletableFutureTest02 {

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(1); //创建线程池

        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("run task...");
            System.out.println(Thread.currentThread().getName());
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello supplyAsync";
        },threadPool); //默认有线程池，也可自定义指定

        try {
            System.out.println(completableFuture.get()); //获取返回结果
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        threadPool.shutdown(); //关闭线程池
    }
}

CompletableFuture常用方法

supplyAsync有返回值，回调函数 & 异常处理
/**
 * CompletableFuture
 * 静态方法 supplyAsync 有返回值
 * 回调函数 & 异常处理
 */
public class CompletableFutureTest03 {

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(1); //创建线程池
        try {

            CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println("run task...");
                System.out.println(Thread.currentThread().getName());
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                int res = ThreadLocalRandom.current().nextInt(10);//产生随机数
                //res/=0; //模拟异常
                return res;
            },threadPool).whenComplete((v,e)->{ //任务执行完毕，回调函数
                if (e==null){
                    System.out.println("任务执行完毕，没有出错！res="+v);
                }
            }).exceptionally(e->{ //任务执行出现异常，异常处理
                System.err.println("出现的异常：=>>"+e.getCause());
                return null;
            });

            System.out.println(completableFuture.get()); //获取返回结果

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown(); //关闭线程池
        }
    }
}
supplyAsync有返回值，返回结果处理
  • thenApply(无异常处理) & handle(有异常处理)
/**
 * CompletableFuture
 * 返回结果处理 thenApply(无异常处理) & handle(有异常处理)
 *
 *             thenApply(f->{
 *                 return f+2;
 *             })
 *
 *            handle((v,e)->{
 *                 if (e==null){
 *                     return v+2;
 *                 }
 *                 System.err.println(e.getCause());
 *                 return null;
 *             })
 */
public class CompletableFutureTest04 {

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(1); //创建线程池
        try {

            CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println("run task...");
                System.out.println(Thread.currentThread().getName());
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                int res = 1;
                //res/=0; //模拟异常
                return res;
            },threadPool).handle((v,e)->{
                if (e==null){
                    return v+2;
                }
                System.err.println(e.getCause());
                return null;
            }).whenComplete((v, e)->{ //任务执行完毕，回调函数
                if (e==null){
                    System.out.println("任务执行完毕，没有出错！res="+v);
                }
            }).exceptionally(e->{ //任务执行出现异常，异常处理
                System.err.println("出现的异常：=>>"+e.getCause());
                return null;
            });

            System.out.println(completableFuture.get()); //获取返回结果

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown(); //关闭线程池
        }
    }
}
supplyAsync有返回值，返回结果消费 (消费完 无返回值)
  • thenRun & thenAccept
/**
 * CompletableFuture
 * 返回结果消费 (消费完 无返回值)
 * thenRun & thenAccept
 */
public class CompletableFutureTest05 {

    public static void main(String[] args) {
        //重新启动一个线程，无需上一个任务结果和传入参数
        System.out.println(CompletableFuture.supplyAsync(()->"A").thenRun(()->{}).join());

        //消费上一个任务结果
        System.out.println(CompletableFuture.supplyAsync(()->"A").thenAccept(r->{
            System.out.println(r);
        }).join());
    }
}
supplyAsync有返回值，比较两个任务计算速度 (谁快)
  • applyToEither
/**
 * CompletableFuture
 * 比较两个任务计算速度 (谁快)
 * applyToEither
 */
public class CompletableFutureTest06 {

    public static void main(String[] args) {
        CompletableFuture<String> res1 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "1号";
        });

        CompletableFuture<String> res2 =CompletableFuture.supplyAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "2号";
        });

        CompletableFuture<String> ans = res1.applyToEither(res2, f -> {
            return f + "is win";
        });

        System.out.println(ans.join());
    }
}
supplyAsync有返回值，合并两个任务计算结果
  • thenCombine
/**
 * CompletableFuture
 * 合并两个任务计算结果
 * thenCombine
 */
public class CompletableFutureTest07 {

    public static void main(String[] args) {
        CompletableFuture<Integer> res1 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 10;
        });

        CompletableFuture<Integer> res2 =CompletableFuture.supplyAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 20;
        });

        CompletableFuture<Integer> ans = res1.thenCombine(res2,(x,y)->{
            return x+y;
        });

        System.out.println(ans.join());
    }
}
林邵晨
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
CompletableFuture 异步处理
07-16
异步编程通常与回调函数、事件驱动或承诺（Promise）机制相关联，Java中的CompletableFuture是另一种实现异步编程的方式。 【CompletableFuture】 CompletableFuture是Java 8引入的一个高级异步编程工具，它是...
java异步编程详解
08-26
java异步编程详解 Java异步编程是Java编程语言中的一种编程模型，它允许程序异步地执行任务，以提高程序的性能和响应速度。在Java中，异步编程可以通过多种方式实现，包括使用Future、Callable、Runnable、Thread、...
CompletableFuture(异步任务编排)
时莫如初的博客
08-04 5985
当我们需要异步调用任务并且需要异步任务的返回值时我们就需要使用FutureTask的get方法来获取返回值.程序输出1231加入我们的异步任务非常的耗时由于get方法会阻塞主线程就会导致程序的吞吐量下降程序输出1123必须要等异步任务完成才能继续执行主线程,不仅如此，当我们在碰到一下业务场景的时候，单纯使用Future接口或者FutureTask类并不能很好地完成以下我们所需的业务....
CompletableFuture多任务异步，获取返回值，汇总结果
一生编程，快乐编程
10-20 3270
supplyAsync(): 异步处理任务，有返回值whenComplete()：任务完成后触发，该方法有返回值。还有两个参数，第一个参数是任务的返回值，第二个参数是异常。allOf()：就是所有任务都完成时触发。allOf()可以配合get()一起使用。/*** 异步，多任务。汇总返回值*///该线程池仅用于示例，实际建议使用自定义的线程池//线程安全的list，适合写多读少的场景//任务完成时执行。用list存放任务的返回值if (result!= null) {
CompletableFuture 多任务异步查询 合并结果
最新发布
天痕
05-31 152
CompletableFuture 多任务异步查询 合并结果
CompletableFuture 异步编排学习一
m0_49692893的博客
04-09 408
CompletableFuture 是 jdk8 的新特性，CompletableFuture 实现了 CompletionStage 接口和 Future 接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利，可用于线程异步编排，使原本串行执行的代码，变为并行执行，提高代码执行速度。
Java8使用CompletableFuture实现多异步任务同步等待结果
User_xiangpeng的专栏
07-29 3658
使用CompletableFuture实现异步执行，等待所有查询结果，所需时间则为3个查询中最大的时间， 如下的示例中，3个查询共需要6秒，使用CompletableFuture优化后仅需3秒！在实际的开发工作中，我们可能会遇到一些比较复杂且耗时的功能，例如一个业务数据表格的导出，假定业务数据表本身都很大，需要组装的数据又比较多，就会造成整个实现过程很耗时甚至可能出现接口请求超时；在实际开发中使用，推荐使用线程池去执行异步任务，supplyAsync()重载的方法中有支持线程池对象参数，快去体验吧！
Java中CompletableFuture多线程任务异步编排
曹举的个人博客
05-28 3474
今天来简单看一下CompletableFuture多线程任务异步编排 为什么需要CompletableFuture？ 当多线程任务出现了相互依赖，需要按照一定的顺序执行的时候就需要用到CompletableFuture多线程任务异步编排 按照我的理解：CompletableFuture可以分为一下几种情况 1、单任务 2、两任务的编排 3、三任务的编排 4、多任务的编排 ...
Java并发 CompletableFuture异步编程的实现
08-25
Java并发 CompletableFuture异步编程的实现 在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而...
多线程异步编程之CompletableFuture入门-release
02-02
强化学习.您将收获: - 为什么会选择 CompletableFuture - 如何创建CompletableFuture异步任务 - CompletableFuture异步任务回调使用 - CompletableFuture异步任务编排 - CompletableFuture的异常处理
CompletableFuture：Java异步编程利器.pptx.pptx
12-21
CompletableFuture是Java 8中引入的一种新的Future，它是一种异步编程工具，可以用于处理异步任务的结果。 CompletableFuture的特性 CompletableFuture具有非阻塞性，可以在等待结果的同时执行其他任务，而且它支持...
项目实战：使用JUC的CompletableFuture执行任务，并根据返回值执行异步回调
大吉的博客
01-07 1932
前言 程序猿大吉在实施的威逼之下又有了新的需求，翻译成技术语言，大致是这样的： 不停地调用一个远程接口（成千上万次）。该接口会返回一串id，并拿着这个id回写我们本地的数据库。 这个远程接口响应时间特别久，大概要1到3s。而一旦接口返回一串id，并将id回写到本地数据库，这个过程比较短，只需要0.05s左右。 所以我想到了将查询远程接口封装成一个函数，将回写本地数据库封装成一个函数，将异常处理封装成一个函数。这样可以最大程度解耦。 在保证效率的情况下必须是用线程池，使用线程池的话，有两种方法解决该需求：
CompletableFuture 异步多线程使用方法
卓越之识论道，平常之识论事，狭隘之识论人
08-08 2318
CompletableFuture使用教程
CompletableFuture详解
JavaPoet的博客
01-19 1297
最近有一个接口需求，需要从多个服务获取数据返回给前端，如果串行一个一个获取的话，假如每个服务1s，5个服务就要5s，服务越多时间越久。这时候，我们可以将串行获取改为并行获取，大大降低了耗时。并行获取虽然提高了效率，但也有一个问题，如果某个服务异常阻塞，这个接口会一直等到这个服务超时返回（根据设置的超时时间），这时候就需要一个功能，那就是超时获取。超时的并行获取，也是并行去获取数据，但我们规定了一个时间，比如1s，那么获取数据的操作就会在1s返回，没有在规定时间内返回的数据将会被丢弃。
CompletableFuture等待所有任务结束
baidu_34762389的博客
07-30 8426
CompletableFuture.supplyAsync() 带有返回值的异步处理，调用get()阻塞直到具有返回值; 当对多个CompletableFuture进行等待处理时，CompletableFuture提供了 allOf(completableFutures).join() 进行处理；具体使用如下： List<List<ExportInfo>> rs = CollUtil.split(res, 200000); CompletableFuture[] co
CompletableFuture异步并发
warrah 南极狼
02-11 172
异步 completableFuture
【JUC】十二、CompletableFuture（上）
llg___的博客
11-27 980
针对前面提到的Future接口的实现类FutureTask的缺点，考虑传入一个回调函数，当任务完成时，自动去调用，since Java8，有了Future接口的新实现CompleteableFuture，CompletableFuture提供了一种观察者模式类似的机制，可以让任务执行完成后通知监听的一方。
Async注解使用和CompletableFuture注解获取返回值
qq_38042187的博客
03-06 2022
Async注解使用和CompletableFuture注解获取返回值
如何使用CompletableFuture.supplyAsync实现异步操作
lizx1018的博客
02-04 871
如何使用CompletableFuture.supplyAsync实现异步操作
CompletableFuture异步
09-23
CompletableFuture是Java中提供的一种异步编程的工具。它可以用来处理异步计算的结果，并且可以通过一系列的方法来操作和组合这些异步任务。 在给出的引用中，有几个方法和概念需要注意： 1. `thenCombine`方法可以用来整合两个异步计算的结果。它接收两个CompletableFuture对象和一个函数作为参数，这个函数会对两个结果进行处理，并返回一个新的结果。 2. `thenApply`方法可以用来对异步计算的结果进行处理。它接收一个函数作为参数，这个函数会对结果进行处理，并返回一个新的结果。 3. `thenCompose`方法可以用来处理一个异步任务的结果，而这个结果又是一个异步任务。它接收一个函数作为参数，这个函数会对结果进行处理，并返回一个新的CompletableFuture对象。 通过使用这些方法，我们可以方便地处理异步计算的结果，进行各种操作和组合，以实现复杂的异步编程任务。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值