zoukankan      html  css  js  c++  java
  • CompletableFuture 异步编排

    public static void main1(String[] args) throws ExecutionException, InterruptedException {
    
            System.out.println("开始");
    
            //异步编排1 无返回值runAsync()
            CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
                System.out.println("当前线程:" + Thread.currentThread().getId());
                int i = 10 / 2;
                System.out.println("结果运行:" + i);
            }, executor);
    
            //异步编排2 有返回值 supplyAsync()
            //方法完成后的感知
            CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
                System.out.println("当前线程:" + Thread.currentThread().getId());
                int i = 10 / 0;
                System.out.println("结果运行:" + i);
                return i;
            }, executor).whenComplete((result, exception)->{
                //虽然能得到异常信息,却不能修改返回数据,类似监听器
                System.out.println("异步任务完成了,结果是:" + result + ",异常是:" + exception);
            }).exceptionally((throwable -> {
                //可以感知异常,同时返回默认数据
                return 10;
            }));
            System.out.println(future2.get());
    
            //handle()方法执行后的处理(无论成功完成还是失败完成) 就算有异常 也想要结果
            CompletableFuture<Integer> future2_1 = CompletableFuture.supplyAsync(() -> {
                System.out.println("当前线程:" + Thread.currentThread().getId());
                int i = 10 / 4;
                System.out.println("结果运行:" + i);
                return i;
            }, executor).handle((result, throwable)->{
                if (result != null) {
                    return result * 2;
                }
                if (throwable != null) {
                    //出现了异常
                    return 0;
                }
                return 0;
            });
            System.out.println(future2_1.get());
    
            /**
             * 串行化 A任务完成后 -> B任务执行
             * 带Async的意思是:再开一个线程; 否则和A线程共用一个线程
             */
    
            //thenRunAsync() 不能获取到上一步的执行结果 无返回值
            CompletableFuture.supplyAsync(() -> {
                System.out.println("当前线程:" + Thread.currentThread().getId());
                int i = 10 / 4;
                System.out.println("结果运行:" + i);
                return i;
            }, executor).thenRunAsync(() -> {
                System.out.println("任务2启动了");
            }, executor);
    
            //thenAcceptAsync() 能接受上一个任务的结果,但是无返回值
            CompletableFuture.supplyAsync(() -> {
                System.out.println("当前线程:" + Thread.currentThread().getId());
                int i = 10 / 4;
                System.out.println("结果运行:" + i);
                return i;
            }, executor).thenAcceptAsync((result)->{
                System.out.println("任务2启动了" + "上一步执行的结果是:" + result);
            }, executor);
    
            //thenAcceptAsync() 能接受上一个任务的结果,有返回值
            CompletableFuture<String> future2_2 = CompletableFuture.supplyAsync(() -> {
                System.out.println("当前线程:" + Thread.currentThread().getId());
                int i = 10 / 4;
                System.out.println("结果运行:" + i);
                return i;
            }, executor).thenApplyAsync((result) -> {
                System.out.println("任务2启动了" + "上一步执行的结果是:" + result);
                return "hello" + result;
            }, executor);
            System.out.println(future2_2.get());
    
            /**
             * 两个任务组合
             * 两个任务都完成 然后执行第三个 A + B -> C
             */
            CompletableFuture<Object> future3_1 = CompletableFuture.supplyAsync(() -> {
                System.out.println("任务1开始。当前线程:" + Thread.currentThread().getId());
                int i = 10 / 4;
                System.out.println("任务1结束。结果运行:" + i);
                return i;
            }, executor);
            CompletableFuture<Object> future3_2 = CompletableFuture.supplyAsync(() -> {
                System.out.println("任务2开始。当前线程:" + Thread.currentThread().getId());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务2结束...");
                return "hello";
            }, executor);
    
            //runAfterBothAsync()不能感知前两步的执行结果 自己也没有返回值
            future3_1.runAfterBothAsync(future3_2, ()->{
                System.out.println("任务3开始。");
            }, executor);
    
            //thenAcceptBothAsync()能感知前两步的执行结果 自己没有返回值
            future3_1.thenAcceptBothAsync(future3_2, (f1, f2)->{
                System.out.println("任务3开始。之前的结果:f1=" + f1 + ";f2=" + f2);
            }, executor);
    
            //thenCombineAsync()能感知前两步的执行结果, 还能处理前面两个任务的返回值,并生成返回值 自己有返回值
            CompletableFuture<String> future3_3 = future3_1.thenCombineAsync(future3_2, (f1, f2) -> {
                return f1 + ": " + f2 + "->ww";
            }, executor);
            System.out.println(future3_3.get());
    
            /**
             * 两个任务 只要有一个完成就行 就能执行第三个任务 A || B = C
             */
            //runAfterEitherAsync() 不感知前面任务的结果,自己也没有返回值
            future3_1.runAfterEitherAsync(future3_2, () -> {
                System.out.println("任务3开始执行。");
            }, executor);
    
            //acceptEitherAsync() 能感知前面任务的结果,自己没有返回值
            future3_1.acceptEitherAsync(future3_2, (result) -> {//要求任务1、2的返回类型必须相同
                System.out.println("任务3开始执行。" + result);
            }, executor);
    
            //applyToEitherAsync() 能感知前面任务的结果,自己有返回值
            CompletableFuture<String> future3_4 = future3_1.applyToEitherAsync(future3_2, (result) -> {//要求任务1、2的返回类型必须相同
                System.out.println("任务3开始执行。" + result);
                return result.toString() + "哈哈";
            }, executor);
            System.out.println(future3_4.get());
    
            /**
             * 多任务组合
             */
            CompletableFuture<String> future4_1 = CompletableFuture.supplyAsync(() -> {
                System.out.println("查询商品的图片信息……");
                return "hello.jpg";
            }, executor);
            CompletableFuture<String> future4_2 = CompletableFuture.supplyAsync(() -> {
                System.out.println("查询商品的属性……");
                return "黑色 2+64G";
            }, executor);
            CompletableFuture<String> future4_3 = CompletableFuture.supplyAsync(() -> {
                try {
                    Thread.sleep(3000);
                    System.out.println("查询商品的介绍……");//模拟业务时间超长
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "apple";
            }, executor);
    
            //allOf() 所有任务结束后才能继续执行
            CompletableFuture<Void> future4_4 = CompletableFuture.allOf(future4_1, future4_2, future4_3);
            future4_4.get();//等待上面3个任务完成 不可以打印
            System.out.println(future4_1.get() + future4_2.get() + future4_3.get());
    
            //anyOf() 只要一个任务,结束就可以继续执行
            CompletableFuture<Object> future4_5 = CompletableFuture.anyOf(future4_1, future4_2, future4_3);
            future4_5.get();//等待所有任务完成 可以打印
            System.out.println(future4_5.get());
    
            System.out.println("结束");
        }
  • 相关阅读:
    在TreeView控件节点中显示图片
    PAT 甲级 1146 Topological Order (25 分)
    PAT 甲级 1146 Topological Order (25 分)
    PAT 甲级 1145 Hashing
    PAT 甲级 1145 Hashing
    PAT 甲级 1144 The Missing Number (20 分)
    PAT 甲级 1144 The Missing Number (20 分)
    PAT 甲级 1151 LCA in a Binary Tree (30 分)
    PAT 甲级 1151 LCA in a Binary Tree (30 分)
    PAT 甲级 1149 Dangerous Goods Packaging
  • 原文地址:https://www.cnblogs.com/xiaodu9499/p/14807816.html
Copyright © 2011-2022 走看看