异步CompletableFuture简单使用

最新推荐文章于 2024-08-22 18:52:46 发布
最新推荐文章于 2024-08-22 18:52:46 发布
阅读量175 收藏
点赞数
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39469143/article/details/110352767
版权
异步CompletableFuture简单使用

  1. 、runXXX方法都是没有返回结果的，supplyXXX都是有返回结果的。可以传入自定义的线程池，否则就用默认的线程池。**supplyAsync()**方法没有返回值。

    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);

public static void main(String[] args) {
    // 1、简单的执行异步任务
	// 创建一个线程池
CompletableFuture.runAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
}, threadPool);
}

  2. **supplyAsync()**完成回调与异常感知(不传入参数，执行完会返回一个参数)

    // 创建一个线程池
public static ExecutorService threadPool = Executors.newFixedThreadPool(10);

public static void main(String[] args) {
// 2、完成回调与异常感知(不传入参数，执行完会返回一个参数)
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 0;
    System.out.println("运行结果：" + i);
    // 2.1执行完线程后返回的值
    return i;
}, threadPool)
    .whenCompleteAsync((integer, throwable) ->{
    // 2.2可以打印返回值信息和异常信息
    System.out.println("integer = " + integer);
    System.out.println("throwable = " + throwable);
})
    .exceptionally(throwable -> {
    // 2.3可以感知异常，同时返回默认值
    return 10;
});

try {
    //取得返回值内容
    System.out.println("future = " + future.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}
}

  3. **handl()**最终处理

    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);

public static void main(String[] args) {
// 3.方法执行后的处理
CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
    // 3.1执行完线程后返回的值
    return i;
}, threadPool).handle((result, throwable) -> {
    //方法返回后对数据进行处理并且返回,result,throwable是执行过程中抛出的异常
    if (result != null) {
    //    如果有返回值结果，就会进入到这里
        return result * 2;
    }
    if (throwable != null) {
        //出现异常返回0
        return 0;
    }
    return 0;
});
}

  4. 线程串行化

    • thenRun()，只要上一步的任务执行完成，就开始执行thenRun（），带Async默认是异步操作。

    • thenAccept()，消费处理结果。接受上一步任务的处理结果，并消费处理，无返回值结果。

    • thenApply()，当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。

      public static ExecutorService threadPool = Executors.newFixedThreadPool(10);

public static void main(String[] args) {
// 4、线程串行化,thenRunAsync无返回值
//  第一个任务执行
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
    // 2.1执行完线程后返回的值
    return i;
}, threadPool);

// 4.1等第一个任务执行完成后，执行第二个任务
// future.thenRunAsync(() -> {
//     System.out.println("任务二启动了");
// },threadPool);

// 5、thenRunAsync无返回值 接受上一个的返回值结果，但是没有返回值出去
future.thenAcceptAsync(result -> {
    System.out.println("result = " + result);
});

// 6、thenApplyAsync无返回值 接受上一个的返回值结果，有返回值出去
future.thenApplyAsync(result -> {
    return result * 2;
});
}
    1. 两任务组合，两个都要执行

    • runAfterBoth()：组合两个Future，不需要获取future的结果，只需要两个future处理完任务后，处理该任务。

    • thenAcceptBoth()：组合两个Future，获取两个future的返回结果，然后处理任务，没有返回值。

    • thenCombine()：组合两个Future，获取两个future的返回结果，并返回当前任务的返回值。

      public static void main(String[] args) {
    // 6、两任务都要完成
    // 6.1第一个任务
    CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
        System.out.println("任务一线程start：" + Thread.currentThread().getId());
        int i = 10 / 2;
        System.out.println("运行结果：" + i);
        System.out.println("任务一线程end：" + Thread.currentThread().getId());
        // 2.1执行完线程后返回的值
        return i;
    }, threadPool);

    // 6.2第二个任务
    CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
        System.out.println("任务二线程start：" + Thread.currentThread().getId());
        System.out.println("任务二线程end：" + Thread.currentThread().getId());
        return "hello";
    }, threadPool);

    /**
     * 任务一线程start：11
     * 运行结果：5
     * 任务一线程end：11
     * 任务二线程start：12
     * 任务二线程end：12
     * 任务三线程start：14
     * 任务三线程end：14
     */
    //runAfterBoth()：组合两个Future，不需要获取future的结果，只需要两个future处理完任务后，处理该任务。
    future01.runAfterBothAsync(future02, () -> {
        System.out.println("任务三线程start：" + Thread.currentThread().getId());
        System.out.println("任务三线程end：" + Thread.currentThread().getId());
    }, threadPool);

    /**
     * 任务一线程start：11
     * 运行结果：5
     * 任务一线程end：11
     * 任务二线程start：12
     * 任务二线程end：12
     * 任务三线程start：13
     * f1 = 5
     * f2 = hello
     * 任务三线程end：13
     */
    // thenAcceptBoth()：组合两个Future，获取两个future的返回结果，然后处理任务，没有返回值。
    future01.thenAcceptBothAsync(future02, (f1ReturnValue, f2ReturnValue) -> {
        System.out.println("任务三线程start：" + Thread.currentThread().getId());
        System.out.println("f1ReturnValue = " + f1ReturnValue);
        System.out.println("f2ReturnValue = " + f2ReturnValue);
        System.out.println("任务三线程end：" + Thread.currentThread().getId());
    }, threadPool);

    /**
     * 任务一线程start：11
     * 运行结果：5
     * 任务一线程end：11
     * 任务二线程start：12
     * 任务二线程end：12
     * 任务三线程start：13
     * f1ReturnValue = 5
     * f2ReturnValue = hello
     * 任务三线程end：13
     * future3ReturnValue = 5hello
     */
    // thenCombine()：组合两个Future，获取两个future的返回结果，并返回当前任务的返回值。
    CompletableFuture<String> future3ReturnValue = future01.thenCombineAsync(future02, (f1ReturnValue, f2ReturnValue) -> {
        System.out.println("任务三线程start：" + Thread.currentThread().getId());
        System.out.println("f1ReturnValue = " + f1ReturnValue);
        System.out.println("f2ReturnValue = " + f2ReturnValue);
        System.out.println("任务三线程end：" + Thread.currentThread().getId());
        return f1ReturnValue + f2ReturnValue;
    }, threadPool);

    try {
        System.out.println("future3ReturnValue = " + future3ReturnValue.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
}

    1. 两个任务组合，任意一个任务完成的时候，执行这个任务。

      • runAfterEither()：两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值。

      • acceptEither()：两个任务有一个执行完成，获取它的结果，处理任务，没有新的返回值。

      • applyToEither()：两个任务有一个执行完成，获取它的的结果，处理任务，有新的返回值。

        public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
public static void main(String[] args) {
        // 7、两任务中任意一个完成
        // 7.1第一个任务
        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一线程start：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            System.out.println("任务一线程end：" + Thread.currentThread().getId());
            // 2.1执行完线程后返回的值
            return i;
        }, threadPool);

        // 7.2第二个任务
        CompletableFuture<Integer> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二线程start：" + Thread.currentThread().getId());
            System.out.println("任务二线程end：" + Thread.currentThread().getId());
            return 998;
        }, threadPool);


        /**
         * 任务一线程start：11
         * 运行结果：5
         * 任务一线程end：11
         * 任务二线程start：12
         * 任务三线程start：14
         * 任务三线程end：14
         * 任务二线程end：12
         */
        // - unAfterEither()：两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值。
        future01.runAfterEitherAsync(future02,() -> {
            System.out.println("任务三线程start：" + Thread.currentThread().getId());
            System.out.println("任务三线程end：" + Thread.currentThread().getId());
        } , threadPool);

        /**
         * 任务一线程start：11
         * 运行结果：5
         * 任务一线程end：11
         * 任务二线程start：12
         * 任务三线程start：13
         * f1ReturnValue = 5
         * 任务三线程end：13
         * 任务二线程end：12
         */
        // - acceptEither()：两个任务有一个执行完成，获取它的结果，处理任务，没有新的返回值。
        //注意:前面两个任务的返回类型要一致，不然会报错。
        future01.acceptEitherAsync(future02,(returnValue) -> {
            System.out.println("任务三线程start：" + Thread.currentThread().getId());
            System.out.println("returnValue = " + returnValue);
            System.out.println("任务三线程end：" + Thread.currentThread().getId());
        } , threadPool);


        /**
         *任务一线程start：11
         * 运行结果：5
         * 任务一线程end：11
         * 任务二线程start：12
         * 任务二线程end：12
         * 任务三线程start：13
         * returnValue = 5
         * 任务三线程end：13
         * f3ReturnValue：500
         */
        // - applyToEither()：两个任务有一个执行完成，获取它的的结果，处理任务，有新的返回值。
        CompletableFuture<Integer> future03 = future01.applyToEitherAsync(future02, (returnValue) -> {
            System.out.println("任务三线程start：" + Thread.currentThread().getId());
            System.out.println("returnValue = " + returnValue);
            System.out.println("任务三线程end：" + Thread.currentThread().getId());
            return returnValue * 100;
        }, threadPool);
        try {
            System.out.println("f3ReturnValue：" + future03.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        threadPool.shutdown();
    }

      1. 多任务组合

        • allOf()：等待所有任务完成。
        • anyOf()：只要一个任务完成。
        public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
public static void main(String[] args) {
    // 1、查询商品的图片信息！
    CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
        System.out.println("查询商品的图片信息！！");
        return "hello.jpg";
    }, threadPool);

    // 2、查询商品的属性！
    CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
        System.out.println("查询商品的属性！！");
        return "黑色+256G";
    }, threadPool);

    // 3、查询商品的介绍！
    CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
        System.out.println("查询商品的介绍！！");
        return "华为";
    }, threadPool);

    // allOf方法会等待所有的方法完成才继续下一步操作。
    CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);

    try {
        //4、等待所有结果完成
        Void unused = allOf.get();
        System.out.println("unused = " + unused);
        threadPool.shutdown(); //关闭线程池
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }

    // anyOf方法会等待所有的方法完成才继续下一步操作。
    CompletableFuture<Void> anyOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);

    try {
        anyOf.get();
        threadPool.shutdown(); //关闭线程池
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }

}
辉z
关注
专栏目录
Java中的异步编程：使用CompletableFuture
AI天才研究院
07-19 2855
作者：禅与计算机程序设计艺术 在Java中进行异步编程一直是一种困难甚至不可能的事情。由于各种历史原因、一些被遗忘的实现细节、线程池等问题导致了编写异步代码的困难和复杂性。最近的OpenJDK版本引入了一个新特性——CompletableFuture，它提供了一个全新的并发模型——Reactive Streams，用于编写响应式异步流处理
异步神器CompletableFuture
马小婧QAQ
09-09 567
介绍 上个礼拜我们线上有个接口比较慢，这个接口在刚开始响应时间是正常的。但随着数据量的增多，响应时间变慢了。 这个接口里面顺序调用了2个服务，且2个服务之间没有数据依赖。我就用CompletableFuture把调用2个服务的过程异步化了一下，响应时间也基本上缩短为原来的一半，问题解决。 正好上次分享了函数式接口和Stream的使用，这次就分享一下CompletableFuture，里面也用到了大量的函数式接口 想方便的异步执行任务，就必须放到单独的线程中。继承Thread类，实...
Java8新的异步编程方式CompletableFuture实现
08-26
主要介绍了Java8新的异步编程方式CompletableFuture实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【异步 CompletableFuture】
hupengfei_shenyang的博客
05-03 355
线程池 初始化线程的四种方法 1.继承Thread Thread01 thread = new Thread01(); thread.start(); 2.实现runnable接口 Runable01 runable = new Runable01(); Thread thread = new Thread(runable); thread.start(); 3.实现Callable接口+FutureTask Callable01 callable = new Callable01(); Futur
Java CompletableFuture：你真的了解它吗？
最新发布
忆~遂愿的博客
08-22 4813
本文将深入探讨Java的CompletableFuture，一种强大的工具，用于简化异步编程和并发任务管理。我们将介绍CompletableFuture的基本概念、核心方法以及实际应用场景，包括如何创建、组合和处理异步任务。通过详细的示例和最佳实践，读者将学会如何利用CompletableFuture实现非阻塞的异步操作，提升程序的响应能力和可维护性。本文旨在帮助开发者全面理解CompletableFuture的功能，掌握其在现代Java开发中的应用技巧。
CompletableFuture简单使用
跟着互联网
02-23 348
CompletableFuture
CompletableFuture异步编程详细使用教程
爱学习的软件开发的博客
04-29 1706
CompletableFuture是Java 8提供的一种新的编写异步任务的方式，它是一个受检查的异步任务的执行器。它支持多个任务的编排，并提供了用于检查任务执行状态以及支持完成时的回调接口的机制。通过使用CompletableFuture，程序员可以更加灵活地组织异步任务，减少代码量，从而提高程序的性能和效率。
CompletableFuture 异步处理
07-16
以下是一个简单的CompletableFuture使用示例，展示如何异步执行任务并处理结果： ```java Supplier<String> task = () -> { Thread.sleep(2000); // 模拟耗时操作 return "Task Result"; }; CompletableFuture...
异步编程之CompleTableFuture
IT界的一只菜鸟
05-25 853
异步编程之CompleTableFuture 一、前期准备（基础讲解） 1、 什么是异步？ 所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法。在 Java 语言中，简单的讲就是另启一个线程来完成调用中的部分计算，使调用继续运行或返回，而不需要等待计算结果。但调用者仍需要取线程的计算结果。 2、使用前注意点介绍 在并发时代，我们常用多线程来进行异步编程，但是多线程有一个缺点，就是不容易获取线程执行后的值，尽管用一些奇招可以获取，但是这已经远离了我们的初衷。java 1.5提供了一
java异步调用CompletableFuture的使用
09-01
在上面的例子中，我们首先创建了一个线程池，然后使用`CompletableFuture.supplyAsync()`方法将任务异步执行。在这个示例中，任务会休眠1秒钟，然后返回一个字符串结果"Hello, World!"。 接下来，我们通过调用`...
谷粒商城异步编排(三十一)
qq_29860591的博客
07-07 506
CompletableFuture异步编排(193-202) /** * @author WGR * @create 2020/7/7 -- 19:34 */ public class ThreadTest { public static ExecutorService executor = Executors.newFixedThreadPool(10); p...
完全！易懂！看这篇就够啦！CompletableFuture使用教程，Java异步编程的利器！
qq_52462620的博客
08-13 1870
完全！易懂！看这篇就够啦！CompletableFuture使用教程，Java异步编程的利器！涵盖12+方法的介绍，覆盖日常所用的大部分方法。不仅介绍方法，还有提问；不仅介绍如何使用，还介绍为什么这样使用。让你深入理解异步到底是由哪一个线程来执行！
CompletableFuture异步编程
HakuMaster的博客
01-30 340
CompletableFuture是Java 8新增的一个类，用于异步编程，继承了Future和CompletionStage这个Future主要具备对请求结果独立处理的功能，CompletionStage用于实现流式处理，实现异步请求的各个阶段组合或链式处理，因此completableFuture能实现整个异步调用接口的扁平化和流式处理，解决原有Future处理一系列链式异步请求时的复杂编码1、Future 的结果在非阻塞的情况下，不能执行更进一步的操作。
有了 CompletableFuture，使得异步编程没有那么难了！
东升的思考
10-06 1401
本文导读： 业务需求场景介绍 技术设计方案思考 Future 设计模式实战 CompletableFuture 模式实战 CompletableFuture 生产建议 CompletableFuture 性能测试 CompletableFuture 使用扩展 --- 1、业务需求场景介绍 不变的东西就是一直在变化中。 想必，大家在闲暇时刻，会经常看视频，经常用的几个 APP，比如优酷...
【Java8新特性---＞异步处理】CompletableFuture
qq_52793248的博客
12-23 4423
【Java1.8新特性---＞异步处理】ComplatableFuture
【异步操作工具 CompletableFuture 详解】
Java之行
04-19 3107
CompletableFuture方法详解
CompletableFuture
Xiao_xiaoxiao
02-17 497
CompletableFuture 前言创建一个异步操作:runAsync(无返回值)创建一个异步操作:supplyAsync(无返回值)计算结果完成时的回调方法:whenComplete多个任务串行化：thenApply执行任务完成时对结果的处理（有返回值）:handlehandle和whenComplete的区别接收任务的处理结果，进行消费处理（无返回值）：thenAccept上一个任务完成就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值