JAVA多线程异步编排CompletableFuture线程串行化多任务组合------JAVA

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量781 收藏 15
点赞数 19
分类专栏： JAVA # JUC多线程 文章标签： java jvm 后端 分布式 微服务 spring boot spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75960169/article/details/141684575
版权 
package com.alatus.search;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureTest {
    public static ExecutorService service = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws InterruptedException, ExecutionException {
//        CompletableFuture会启动一个异步任务,当它用的是supplyAsync的时候,是可以返回值的
//        我们可以和FutureTask一样通过get来获取这个值
        CompletableFuture.runAsync(() -> {
            System.out.println("异步任务");
        },service);
//        CompletableFuture<Long> longCompletableFuture = CompletableFuture.supplyAsync(() -> {
//            long id = Thread.currentThread().getId();
//            System.out.println(id);
//            int i = 10 / 0;
//            return id;
//        }, service).whenComplete((result,exception)->{
            可以对结果进行获取和异步编排,并输出存在或出现的异常
            但是没法修改返回数据
//            System.out.println("结果是:"+result+"异常是:"+exception);
//        }).exceptionally(throwable -> {
            出现异常的默认返回
            可以修改返回数据
//            return 10L;
//        });
        CompletableFuture<Long> longCompletableFuture = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            int i = 10 / 4;
            return id;
        }, service).handle((result,exception)->{
//            方法完成后的处理,无论是成功完成还是失败完成
            if(result!=null){
                return result;
            }
            if(exception!=null){
                System.out.println(exception);
                return 0L;
            }
            return 0L;
        });
        Long l = longCompletableFuture.get();
        System.out.println(l);
        System.out.println("我是main方法");
//        串行化任务
//        TODO 开启二号线程继续跑的方式,但是接收不到返回值
//        TODO 也用不了上一次的返回值
        CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            int i = 10 / 4;
            return id;
        }, service).thenRunAsync(()->{
            System.out.println("第二个线程启动了");
        },service);
//        TODO 能接收到结果,但是返回值就没了
        CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            int i = 10 / 4;
            return id;
        }, service).thenAcceptAsync(resp->{
            System.out.println("结果是"+resp);
        });
        // TODO 既能接收上一部结果,也有返回值
        CompletableFuture<Long> longCompletableFuture1 = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            int i = 10 / 4;
            return id;
        }, service).thenApplyAsync(resp -> {
            System.out.println("结果是" + resp++);
            return resp;
        });
        // TODO 两个异步任务合并,两个都完成
        CompletableFuture<Long> completableFuture01 = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            return id;
        });
        CompletableFuture<Long> completableFuture02 = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            return id;
        });
        CompletableFuture<Long> completableFuture03 = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            return id;
        });
        completableFuture01.runAfterBothAsync(completableFuture02,()->{
            System.out.println("任务3开始");
        },service).runAfterBothAsync(completableFuture03,()->{
            System.out.println("任务都完成了");
        },service);
//        这里的串行执行使用的都是线程池给到的一个线程,所有的都是这个线程做的
//        但是执行完的值是不能返回再次使用的
        completableFuture01.thenAcceptBothAsync(completableFuture02,(f1,f2)->{
            System.out.println(f1);
            System.out.println(f2);
            System.out.println(f1+f2);
        },service).thenAcceptBothAsync(completableFuture03,(f1,f2)->{
            System.out.println(f2);
            System.out.println(f2);
        },service);
//        组合执行两个任务,并把值保留下来返回
        completableFuture01.thenCombineAsync(completableFuture02,(f1,f2)->{
            return f1+f2;
        },service).thenAcceptBothAsync(completableFuture03,(f1,f2)->{
//            在这里就可以把之前的值拿来用了
            System.out.println(f1+f2);
        },service);
    }
}
package com.alatus.search;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureTest {
    public static ExecutorService service = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws InterruptedException, ExecutionException {
//        CompletableFuture会启动一个异步任务,当它用的是supplyAsync的时候,是可以返回值的
//        我们可以和FutureTask一样通过get来获取这个值
        CompletableFuture.runAsync(() -> {
            System.out.println("异步任务");
        },service);
//        CompletableFuture<Long> longCompletableFuture = CompletableFuture.supplyAsync(() -> {
//            long id = Thread.currentThread().getId();
//            System.out.println(id);
//            int i = 10 / 0;
//            return id;
//        }, service).whenComplete((result,exception)->{
            可以对结果进行获取和异步编排,并输出存在或出现的异常
            但是没法修改返回数据
//            System.out.println("结果是:"+result+"异常是:"+exception);
//        }).exceptionally(throwable -> {
            出现异常的默认返回
            可以修改返回数据
//            return 10L;
//        });
        CompletableFuture<Long> longCompletableFuture = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            int i = 10 / 4;
            return id;
        }, service).handle((result,exception)->{
//            方法完成后的处理,无论是成功完成还是失败完成
            if(result!=null){
                return result;
            }
            if(exception!=null){
                System.out.println(exception);
                return 0L;
            }
            return 0L;
        });
        Long l = longCompletableFuture.get();
        System.out.println(l);
        System.out.println("我是main方法");
//        串行化任务
//        TODO 开启二号线程继续跑的方式,但是接收不到返回值
//        TODO 也用不了上一次的返回值
        CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            int i = 10 / 4;
            return id;
        }, service).thenRunAsync(()->{
            System.out.println("第二个线程启动了");
        },service);
//        TODO 能接收到结果,但是返回值就没了
        CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            int i = 10 / 4;
            return id;
        }, service).thenAcceptAsync(resp->{
            System.out.println("结果是"+resp);
        });
        // TODO 既能接收上一部结果,也有返回值
        CompletableFuture<Long> longCompletableFuture1 = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            int i = 10 / 4;
            return id;
        }, service).thenApplyAsync(resp -> {
            System.out.println("结果是" + resp++);
            return resp;
        });
        // TODO 两个异步任务合并,两个都完成
        CompletableFuture<Long> completableFuture01 = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            return id;
        });
        CompletableFuture<Long> completableFuture02 = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            return id;
        });
        CompletableFuture<Long> completableFuture03 = CompletableFuture.supplyAsync(() -> {
            long id = Thread.currentThread().getId();
            System.out.println(id);
            return id;
        });
        completableFuture01.runAfterBothAsync(completableFuture02,()->{
            System.out.println("任务3开始");
        },service).runAfterBothAsync(completableFuture03,()->{
            System.out.println("任务都完成了");
        },service);
//        这里的串行执行使用的都是线程池给到的一个线程,所有的都是这个线程做的
//        但是执行完的值是不能返回再次使用的
        completableFuture01.thenAcceptBothAsync(completableFuture02,(f1,f2)->{
            System.out.println(f1);
            System.out.println(f2);
            System.out.println(f1+f2);
        },service).thenAcceptBothAsync(completableFuture03,(f1,f2)->{
            System.out.println(f2);
            System.out.println(f2);
        },service);
//        组合执行两个任务,并把值保留下来返回
        completableFuture01.thenCombineAsync(completableFuture02,(f1,f2)->{
            return f1+f2;
        },service).thenAcceptBothAsync(completableFuture03,(f1,f2)->{
//            在这里就可以把之前的值拿来用了
            System.out.println(f1+f2);
        },service);
    }
}
旧约Alatus
关注
专栏目录
CompletableFuture异步串行处理
男人要霸气的博客
04-22 403
public static void main(String[] args) { System.out.println(CompletableFuture.supplyAsync(() -> { return 1; }).thenApply(v -> {//v就是上次处理完成的结果 return v + 1; //v=1 }).thenCombine(CompletableFuture.suppl.
多个CompletableFuture 串行执行
u013672585的博客
11-29 1544
多个CompletableFuture可以串行执行 public class Main { public static void main(String[] args) throws Exception { // 第一个任务: CompletableFuture<String> cfQuery = CompletableFuture.supplyAsync(() -> { return queryCode("中国石油"); ...
CompletableFuture异步编排(线程串行化代码示例)
小志的博客
08-23 515
CompletableFuture异步编排(线程串行化代码示例)
CompletableFuture四种执行关系
双木林的那个林的博客
02-26 290
CompletableFuture四种执行关系
Java CompletableFuture实现多线程异步编排
m0_73311735的博客
09-07 1074
在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。CompletableFuture类实现了Future接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。
Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
热门推荐
qq_35716689的博客
03-20 25万+
CompletableFuture为Java提供了强大的异步编程能力,可以极大地提高应用的并发能力和响应速度。通过并行执行多个查询任务,我们可以大幅减少接口的响应时间,优化用户体验。同时,CompletableFuture的代码风格函数式、简洁、优雅,也使得代码更加易读易维护。 但是,异步编程也不是万能的,它需要开发者转变思维模式,还需要权衡利弊。在实际项目中,我们可以结合其他优化手段,选择合适的方案,以达到最佳的性能效果。
Java多线程--CompletableFuture异步编排
sunao1106的博客
07-28 955
举一个形象的例子： 在一个方法中实现了A、B、C三个功能，假设每个功能的执行所需要的时间分别为(5s，10s，15s)，在没有异步编排之前，进入方法依次执行 A功能—>B功能—>C功能，执行方法完毕，用时30s。当我们在方法中引入异步编排，给A、B、C每个功能都分配一个不同的线程执行，这样的情况下，最快15s这个方法就可以执行完毕，这就是所谓的异步。.........
Java多线程----创建线程、线程池ExecutorService、异步编排CompletableFuture
idooy的学习笔记
11-02 950
自定义类实现Runnable接口；通过的方式创建线程// 方式1；继承Thread类// 方式2；实现Runnable接口).start();Java中线程池就是Executor或者对象实例之前通过不能重复利用线程，有多少任务就创建多少个线程如果需要处理大量任务，就需要频繁地创建和销毁线程会浪费时间和效率如果同一时刻存在大量的线程，那么线程之间还存在竞争资源，CPU上下切换等问题线程池通过预先创建一定数量的线程，让这些线程处理来自任务队列中的任务，而不是频繁创建和销毁线程。
Java多线程【异步编排】
大脑不能为空
10-13 3992
Java线程和进程的区别，为什么要有线程池，JUC并发编程教程。
多线程 - Thread 使用、线程状态、 CompletableFuture 异步编排
CYK_byte的博客
04-27 1209
Ps：创建线程的时候，给线程起个名字还是很有必要的，目的就是为了方便程序员调试，一旦出问题，方便找到对应的代码，如果不手动起名，JVM 默认会起名为 thread-0、thread-1......操作系统管理这些线程的 PCB 的时候，是有多个链表的，调用了sleep ，就会把 PCB 移动另外一个“阻塞队列”（原先在“就绪队列”），当 sleep 时间到了 ，就会被移动到之前的就绪队列。Ps：直接调用 run 并不会创建线程，只是运行线程中的代码，调用 start 方法，才是创建了线程。
线程异步编排串行（CompletableFuture）
伍妖捌的小屋
06-27 425
美图 创建异步对象 CompletableFuture提供了四个静态方法来创建一个异步操作 无返回值 不需要指定线程池，使用默认线程池 CompletableFuture<Void> runAsync(Runnable runnable); 需要指定线程池，使用指定线程池 CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) 有返回 不需要指定线程池，使用默认线程池 Comple
CompletableFuture实现多线程异步任务编排
sinat_31583645的博客
02-24 1373
在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture，提供了非常强大的Future扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。CompletableFuture类实现了Future接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。CompletableFuture和FutureTask同属于Future接口。
异步-CompletableFuture详解
weixin_42506047的博客
10-21 521
1.0 线程回顾 1.1 初始化线程的4中方式 继承Thread 实现Runnable接口 实现Callable 接口+FutureTask (可以拿到返回结果,可以处理异常) 线程池 通过线程池性能稳定，也可以获取执行结果，并捕获异常。但是，在业务复杂情况下，一个异步调用可能会依赖于另一个异步调用的执行结果。 import java.util.concurrent.*; public class ThreadTest { public static ExecutorService ser
02-CompletableFuture系列-异步任务串行执行
qq_38125615的博客
05-27 1450
CompletableFuture实现了两个接口： 1、Future 解决异步操作什么时候结束，如方法get()、isDone() 2、CompletionStage 解决异步操作的结果如何获取。在1.8版本中CompletionStage有40个方法。 我们都知道任务执行是有时序关系的。 1、串行：前一个任务执行完才能执行后一个任务。 2、并行：多个任务可以并行执行。 3、汇聚：将多个任务的执行结果聚合。 汇聚又可以分为： 1）AND聚合：所有依赖的任务全部执行完才能进行下一步。 2）OR聚合：依赖的任务
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 620
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1113
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 769
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 448
默认对常规Session的理解和使用，如何使用Set-Cookie。
Cocos2d-x 3.0 异步多线程资源加载优化实战
Cocos2d-x 3.0多线程异步加载资源实例是针对手机游戏开发中常见问题的一种解决方案。随着游戏复杂度的提升，尤其是休闲小游戏，对纹理资源、音视频、文件读写和网络通信的需求日益增加，这可能导致游戏性能瓶颈，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值