JUC之CompletableFuture

最新推荐文章于 2024-04-26 12:09:43 发布
最新推荐文章于 2024-04-26 12:09:43 发布
阅读量955 收藏 18
点赞数 21
分类专栏： JUC 文章标签： java 数据库 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44850917/article/details/135557636
版权

Future接口理论

Future接口定义了异步任务执行的一些方法，包括异步任务执行结果，异步任务执行是否中断，异步任务是否完毕等。

Future接口常用实现类FutureTask异步任务

        FutureTask<String> futureTask = new FutureTask<String>( () -> {
            System.out.println(Thread.currentThread().getName()+"\t -----come in");
            try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }
            return "task over";
        });
        Thread t1 = new Thread(futureTask, "t1");
        t1.start();

CompletableFuture

CompletableFuture对Future的改进

  • CompletableFuture异步线程发生异常，不会影响到主线程，用来记录日志特别方便。
  • CompletableFuture出现的原因：Future的get方法是阻塞方法，当异步线程计算完成之前一直会阻塞，isDone()方法判断异步线程又特别消耗CPU资源。对于真正的异步处理我们希望传入回调函数，在Future结束时，自动调用该回调函数。这样我们就不用等待结果 。
  • CompletableFuture提供了一种观察者模式，可以让任务完成后通知监听的一方。
    在这里插入图片描述

CompletionStage

  • CompltionStage是异步执行的一个阶段。一个阶段执行完成之后可能触发另一个阶段。
  • 一个阶段的执行可以是一个Function,Comsumer或者Runnable。比如
 stage.thenApply(x -> square(x)).thenAccept(×->System.out.print(x)).thenRun(( ->system.out.println())
  • 一个阶段可能会是另一个阶段完成后触发。也可能是其他多个阶段完成后触发。

CompletableFuture的方法

在这里插入图片描述
主要是runAsync和supplyAsnc方法。一个无返回值。一个有返回值。

CompletableFuture的优点

  • 异步任务执行完成后，会自动调用某个对象的方法
  • 异步任务出异常后，会自动调用某个对象的方法
  • 主线程设置好回调后，不用关心异步任务的执行。异步任务之间可以顺序执行。

案例 - 前言

join和get的区别。get必须处理异常。join不需要处理异常
jdk8新特性： lambda表达式，stream流，chain链式调用，函数式编程
在这里插入图片描述
有参数，有返回值：Function
有参数，无返回值：Consume, BiConsumer（两个参数）
无参数，有返回值：Supplier
无参数，无返回值：Runnable

案例-从电商网站的比价需求

原来的写法，串行的方式：

    /**
     * step by step 一家家搜查
     * List<NetMall> ----->map------> List<String>
     * @param list
     * @param productName
     * @return
     */
    public static List<String> getPrice(List<NetMall> list,String productName)
    {
        //《mysql》 in taobao price is 90.43
        return list
                .stream()
                .map(netMall ->
                        String.format(productName + " in %s price is %.2f",
                                netMall.getNetMallName(),
                                netMall.calcPrice(productName)))
                .collect(Collectors.toList());
    }

使用CompletableFuture，异步的方式：

 /**
     * List<NetMall> ----->List<CompletableFuture<String>>------> List<String>
     * @param list
     * @param productName
     * @return
     */
    public static List<String> getPriceByCompletableFuture(List<NetMall> list,String productName)
    {
        return list.stream().map(netMall ->
                CompletableFuture.supplyAsync(() -> String.format(productName + " in %s price is %.2f",
                netMall.getNetMallName(),
                netMall.calcPrice(productName))))
                .collect(Collectors.toList())
                .stream()
                .map(s -> s.join())
                .collect(Collectors.toList());
    }

耗时：比串行的方式快得多！！！

CompletableFuture 常用方法

获得结果和触发计算

获得结果：

  • public T get() 一直等
  • public T get(long timeout,TimeUnit unit) 过时不候，到了时间没拿到结果会报异常
  • public T join()：join和get都是用来获取CompletableFuture异步之后的返回值。join是unchecked异常（即运行时异常）。get是checked异常（经过检查的异常）
  • public T getNow(T valuelfAbsent)：没有计算完，给我默认的结果。计算完，返回实际的结果。

主动触发计算：

  • public boolean complete(T value) 如果CompletableFuture没有完成，将get结果修改为value，返回值为true。如果完成了，不修改get，返回值为false.
public class CompletableFutureTest {

  public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
      CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
          try {
              Thread.sleep(2000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          return "hello CompletableFuture";
      });

      System.out.println(completableFuture.getNow("心急吃不了热豆腐"));
      System.out.println(completableFuture.get());
      System.out.println(completableFuture.get(1500, TimeUnit.MILLISECONDS));
      System.out.println(completableFuture.join());
      System.out.println(completableFuture.complete("未雨绸缪")+"\t"+completableFuture.join());

  }
}

对计算结果进行处理

thenApply（常用）

两个计算结果存在依赖关系，这两个线程串行化。
出现异常，直接跳到whenComplete和exceptionally执行。（不再执行后续的thenApply）

public class CompletableFutureTest2 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 6;
        },executorService).thenApply((r)-> {
            int i=2/0;
            return r * 5;
        }).thenApply((r)-> {
            System.out.println(r);
            return r - 2;
        }).whenComplete((v, e) -> {
            System.out.println("计算结果："+v);
        }).exceptionally(e -> {
            System.out.println(e.getMessage());
            System.out.println(e);
            return null;
        });
        System.out.println("============主线程==========");
        executorService.shutdown();
    }
}

handle

计算机结果存在依赖关系，两个线程串行化
handle出现异常，会往下一个handle走，同时也会走到whenComplete和exceptionally

public class CompletableFutureTest2 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 6;
        },executorService).handle((r,e)-> {
            int i=2/0;
            return r * 5;
        }).handle((r,e)-> {
            System.out.println(r);
            return r - 2;
        }).whenComplete((v, e) -> {
            System.out.println("计算结果："+v);
        }).exceptionally(e -> {
            System.out.println(e.getMessage());
            System.out.println(e);
            return null;
        });
        System.out.println("============主线程==========");
        executorService.shutdown();
    }
}

exceptionally相当于try catch
whenComplete和handler相当于try finally
在这里插入图片描述

对计算结果进行消费

接受任务的处理结果，消费处理。thenAccept无返回结果。（thenApply是有返回结果的）

public class CompletableFutureTest3 {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(()->{
            return 3;
        }).thenApply(r->{
            return r*8;
        }).thenApply(r->{
            return r/2;
        }).thenAccept(r-> System.out.println(r));
        System.out.println(CompletableFuture.supplyAsync(()->"6666").thenRun(()->{}).join());
        System.out.println(CompletableFuture.supplyAsync(()->"6666").thenAccept(r-> System.out.println(r)).join());
        System.out.println(CompletableFuture.supplyAsync(()->"6666").thenApply(r->r+"9999").join());
    }
}


12
null
6666
null
66669999

对计算速度进行选用与对计算结果进行合并

applyToEither：谁快用谁
thenCombine: 两个completionStage任务都完成后，将结果交给thenCombine。先完成的先等着，等待其他分支任务。

public class CompletableFutureTest4 {
    public static void main(String[] args) {
        CompletableFuture<String> first = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "1号选手";
        });
        CompletableFuture<String> second = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "2号选手";
        });
        CompletableFuture<String> result = first.applyToEither(second, r -> r + "is winner");
        CompletableFuture<String> res = first.thenCombine(second, (x, y) -> x + y);
        System.out.println(result.join());
        System.out.println(res.join());
    }
}

并行执行

allOf():当所有给定的CompletableFuture完成时， 返回一个新的CompletableFuture
anyOf():当任何一个给定的CompletableFuture完成时，返回一个新的CompletableFuture

	public static void testAllOf(){
        CompletableFuture<String> future1 = CompletableFuture.runAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("future1执行完成");
        });

        CompletableFuture<String> future2 = CompletableFuture.runAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("future2执行完成");
        });

        CompletableFuture<Void> all = CompletableFuture.allOf(future1, future2);
			try {
            all.get(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }

completableFuture和线程池说明

以thenRun和thenRunAsync为例，有什么区别？

  • 没有传入自定义线程池，默认是ForkJoinPool.
  • 如果第一个执行的任务传入了一个自定义线程池，调用thenRun执行第二个任务，则第一个和第二个都是用自定义的线程池。
  • 如果第一个执行的任务传入了一个自定义线程池，调用thenRunAsyn执行第二个任务，则第一个用自定义。第二个用ForkJoinPool（后面也都是ForkJoinPool）
--believe
关注
  • 21
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java——JUC
12-29
用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;包含下载地址
JUC 之 CompletableFuture
bad_boy的博客
02-25 527
至此引出 CompletableFuture，以声明式的方式优雅处理这些需求，Future 能干的，CompletableFuture 都能干。简单的业务场景使用 Future 完全 OK。
JUC之 completableFuture
m0_53144238的博客
08-23 145
CompletableFuture用法、优点
java juc之CompletableFuture
weixin_43785508的博客
02-17 223
CompletableFuture
JUC 之 CompletableFuture使用详解
老猫喜欢今日爬山的博客
11-08 207
exceptionally：返回一个新的CompletableFuture，当前面的CompletableFuture完成时，它也完成，当它异常完成时，给定函数的异常触发这个CompletableFuture的完成。方法不以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其它的线程去执行(如果使用相同的线程池，也可能会被同一个线程选中执行)。allOf()：当所有给定的 CompletableFuture 完成时，返回一个新的 CompletableFuture。
heima-JUC-资料
04-25
heima-JUC-资料
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
JUC线程高级
02-27
JUC线程高级,
juc aqs java
12-14
juc 的aqs介绍。
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 260
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1391
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 519
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1291
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 746
consul官网地址。
迭代器模式
LuckFairyLuckBaby的博客
04-23 444
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java的Arrays的基础知识
2301_80142564的博客
04-23 1137
在Java中，Arrays是一个用于操作数组的工具类，它提供了很多静态方法来处理数组，如排序、搜索、比较等。这个类在java.util包中，因此在使用之前需要导入这个包。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 689
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
java通过Comparator比较器对集合进行多属性连续分组内升降排序，以及null空值排最前或最后
最新发布
hkl_Forever的博客
04-26 131
一、排序数据准备，分别对 one、two、three 三个属性进行连续分组内排序。连续排序，并且把被排序属性值为null的排在最后。连续排序，并且把被排序属性值为null的排在最后。
JUC包CompletableFuture
10-13
CompletableFuture是Java8引入的JUC包中的一个类，用于异步编程和函数式编程。它可以让我们更加方便地进行异步任务的处理，避免了传统的回调地狱问题。 具体来说，CompletableFuture可以通过thenApply、thenAccept、thenRun等方法串联多个异步任务，也可以通过allOf、anyOf等方法组合多个异步任务。此外，CompletableFuture还支持异常处理、超时控制等功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值