CompletableFuture demo

于 2023-07-12 20:00:09 发布
阅读量232 收藏
点赞数
文章标签： python 开发语言
原文链接：https://blog.csdn.net/qq_40922616/article/details/121045841
版权

目录标题

前置知识：函数式接口

Function类

特点：有入参T，有返回值R

@FunctionalInterface
public interface Function<T, R> {
    R apply(T var1);
}

Consumer类

特点：有入参T，无返回值

@FunctionalInterface
public interface Consumer<T> {
    void accept(T var1);
}

Supplier类

特点：无入参，有返回值T

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Predict类

特点：有入参T，有返回值boolean

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T var1);
｝

总结

在这里插入图片描述

CompletableFuture

在工作中，常常会调用多个服务或者方法去获取不同的数据，如果传统做法就是串行一个个获取，然后封装返回。我们可以尝试使用CompletableFuture，将多个操作交给异步线程执行，然后主线程等待最长任务完成，将所有结果一并返回即可。

1. 创建实例

// 无入参有返回值
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier);
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor);
// 无入参无返回值，简单的执行
public static CompletableFuture<Void> runAsync(Runnable runnable);
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);

我们注意到每种方法都有一个重构的方法。Executor参数可以手动指定线程池，否则默认ForkJoinPool.commonPool()系统级公共线程池。
默认的commonPool的这些线程都是守护线程。我们在编程的时候需要谨慎使用守护线程，如果将我们普通的用户线程设置成守护线程，当我们的程序主线程结束，JVM中不存在其余用户线程，那么CompletableFuture的守护线程会直接退出，造成任务无法完成的问题！！

demo - runAsync不带线程池

主线程执行完毕就结束，无论异步线程任务执行进度

CompletableFuture<Void> runAsync = CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(3000);
        System.out.println("线程[" + Thread.currentThread().getName() + "]异步执行");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
});
System.out.println("线程[" + Thread.currentThread().getName() + "],结束");

在这里插入图片描述

demo - runAsync带线程池

不需要异步任务执行结果，并且保证异步任务可以正常执行完成

 //解决方案1： 增加抵定义线程池
 CompletableFuture<Void> runWithThreadPool = CompletableFuture.runAsync(() -> {
     try {
         Thread.sleep(3000);
         System.out.println("线程[" + Thread.currentThread().getName() + "]异步执行,自定义线程池");
     } catch (InterruptedException e) {
         throw new RuntimeException(e);
     }
 }, queryBestThreadPool);

 System.out.println("线程[" + Thread.currentThread().getName() + "]结束");

在这里插入图片描述

demo - get()阻塞等待结果

需要异步任务执行结果的场景，变成同步

CompletableFuture<Void> runAsync = CompletableFuture.runAsync(() -> {
     try {
         Thread.sleep(3000);
         System.out.println("线程[" + Thread.currentThread().getName() + "]异步执行");
     } catch (InterruptedException e) {
         throw new RuntimeException(e);
     }
 });
 runAsync.get();
 System.out.println("线程[" + Thread.currentThread().getName() + "]结束");

在这里插入图片描述

demo - supplyAsync不带线程池

CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> {
try {
      Thread.sleep(3000);
      System.out.println("线程[" + Thread.currentThread().getName() + "]异步执行");
  } catch (InterruptedException e) {
      throw new RuntimeException(e);
  }
  return "success";
});
//主线程执行完毕，结束
System.out.println("线程[" + Thread.currentThread().getName() + "结束");

CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> {
try {
      Thread.sleep(3000);
      System.out.println("线程[" + Thread.currentThread().getName() + "]异步执行");
  } catch (InterruptedException e) {
      throw new RuntimeException(e);
  }
  return "success";
});
//supplyAsync.get() 会阻塞等待异步任务执行结果，结果返回，主线程打印日志，结束
System.out.println("线程[" + Thread.currentThread().getName() + "],get()="+supplyAsync.get());

demo - supplyAsync带线程池

CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(3000);
        System.out.println("线程[" + Thread.currentThread().getName() + "]异步执行");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return "success";
}, queryBestThreadPool);
//主线程走完，结束
System.out.println("线程[" + Thread.currentThread().getName() + "],结束");
//后续异步线程正常执行完成，打印日志

在这里插入图片描述

CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(3000);
        System.out.println("线程[" + Thread.currentThread().getName() + "]异步执行");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return "success";
}, queryBestThreadPool);
//主线程阻塞等待异步结果，拿到结果后，主线程正常走
System.out.println("线程[" + Thread.currentThread().getName() + "],get()="+supplyAsync.get());

在这里插入图片描述

2. whenComplete

考虑当我们在CompletableFuture执行结束的时候，希望能够得到执行结果、或者异常，然后对结果或者异常做进一步处理。那么我们就需要使用到whenComplete。

CompletableFuture<String> supply = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
   //int a = 1 / 0;
    System.out.println("线程[" + Thread.currentThread().getName() + "],多线程异步执行完成");
    return "success";
    //如果这里不加线程池，主线程任务执行完毕，结束。（不会等异步线程，也不会执行到whenComplete代码里）
}, queryBestThreadPool);

//没有返回
//res：上一步执行结果  ex：上一步抛出的异常
CompletableFuture<String> complete = supply.whenComplete((res, ex) -> {
    if (Objects.nonNull(ex)) {
        ex.printStackTrace();
        System.out.println("失败,线程[" + Thread.currentThread().getName() + "],res: " + res + ",throws：" + ex);
    } else {
        System.out.println("成功,线程[" + Thread.currentThread().getName() + "],res: " + res + ",throws：" + ex);
    }
});
//异常以后，不走下面这行代码，get()抛出的异常，如果异常后，有其他的逻辑需要处理，可以将get() try起来～
System.out.println("线程[" + Thread.currentThread().getName() + "],complete.get():" + complete.get() + ",supply.get():" + supply.get());

正常执行
在这里插入图片描述
异常执行
在这里插入图片描述

3. handle

CompletableFuture<String> supply = CompletableFuture.supplyAsync(() -> {
    // int a = 1 / 0;
    System.out.println("线程[" + Thread.currentThread().getName() + "],多线程异步执行完成");
    return "success";
}, queryBestThreadPool);

CompletableFuture<String> complete = supply.handle((res, ex) -> {
    if (Objects.nonNull(ex)) {
        ex.printStackTrace();
        System.out.println("线程[" + Thread.currentThread().getName() + "],异常,res: " + res + ",throws：" + ex);
        return null;
    } else {
        res = res + "重新组装";
        System.out.println("线程[" + Thread.currentThread().getName() + "],成功,res: " + res);
        return res;
    }
});
//异常后，不走下面
System.out.println("线程[" + Thread.currentThread().getName() + "],结束,supply.get()=" + supply.get() + ",complete.get()=" + complete.get());

正常执行
在这里插入图片描述
异常执行
在这里插入图片描述

4. exceptionally

当发生异常时候的处理，注意异常后返回值类型需要和发生异常的CF返回值类型一致，相当于一种服务降级的思想。

CompletableFuture<String> supply = CompletableFuture.supplyAsync(() -> {
 int a = 1 / 0;
    System.out.println("线程[" + Thread.currentThread().getName() + "],多线程异步执行完成");
    return "success";
}, queryBestThreadPool)
.exceptionally(e -> {
    System.out.println("线程[" + Thread.currentThread().getName() + "],异常,e="+e);
    e.printStackTrace();
    return "error";
});
System.out.println("线程[" + Thread.currentThread().getName() + "],结束,supply.get()=" + supply.get());

正常执行
在这里插入图片描述
异常执行
在这里插入图片描述

5. CompletableFuture组合式Api - allOf

allOf 的返回值是 CompletableFuture类型，这是因为 每个传入的 CompletableFuture 的返回值都可能不同，所以组合的结果是 无法用某种类型来表示的，索性返回 Void 类型。

    static void allof(ThreadPoolTaskExecutor queryBestThreadPool) throws Exception {

        List<Integer> result = new ArrayList<>();

        List<Integer> errorId = new ArrayList<>();
        List<Integer> successId = new ArrayList<>();

        List<CompletableFuture> taskList = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            final Integer temp = i;
            CompletableFuture<Integer> supplyAsyncRes = CompletableFuture.supplyAsync(() -> {
                //处理核心逻辑
                if (temp == 3 || temp == 6 || temp == 9) {
                    int a = 1 / 0;
                }
                System.out.println("线程[" + Thread.currentThread().getName() + "],多线程异步执行完成,i:" + temp);
                return temp;
            }, queryBestThreadPool).whenComplete((res, error) -> {
                if (Objects.nonNull(error)) {
                    errorId.add(temp);
                } else {
                    successId.add(res);
                }
            });
            taskList.add(supplyAsyncRes);
        }

        CompletableFuture.allOf(taskList.toArray(new CompletableFuture[taskList.size()]));
        //阻塞等待任务完成

        for (CompletableFuture cf : taskList) {
            try {
                result.add((Integer) cf.get());
            } catch (Exception e) {
                System.out.println(Thread.currentThread().getName() + "异常啦");
                e.printStackTrace();
            }
        }
        System.out.println("successId:" + successId);
        System.out.println("errorId:" + errorId);

        if (CollectionUtils.isNotEmpty(errorId)) {
            throw new CustomException(CustomExceptionEnum.FAIL);
        }
        //成功后的逻辑
        System.out.println("线程[" + Thread.currentThread().getName() + "],结束,res:" + result);

前置知识来源：https://endwas.cn/blog/78
demo来源：https://blog.csdn.net/qq_40922616/article/details/121045841

桃月十二_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CompletableFuture多任务异步处理框架简单入门demo
没啥简介
11-21 5772
CompletableFuture多任务异步处理框架简单入门demo 功能简介： 将任务拆分成多个，交给线程池分别执行，然后获取所有结果，或者不获取结果。 也可以链式执行任务，比如批量入库中一个用户入库成功后发送kafka,再更新缓存，然后响应。 在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。 它可能代
CompletableFuture的demo
HEHUACHAO425的博客
04-01 554
import java.util.Objects; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Exec
JDK1.8新特性:CompletableFuture技术的demo实现案例
m0_50700216的博客
08-21 309
当我们在整体代码运行时可以正常执行但是因为代码的串行化而导致了执行效率太低时可以考虑线程的并行执行,但是常规的Runnable代码过于复杂,而JDK1.8的新特性能够通过lambda表达式的方式实现多线程执行,并且支持单个线程执行完时等待其他线程.
多线程学习一CompletableFutureDemo使用
qq_40447533的博客
10-07 199
package ThreadDemo; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.concurrent.*; import java.util.function.Function; import java.util.stream.Collectors; import lombok.var; import org.apache.poi.ss.for.
CompletableFuture——基本用法demo,推荐收藏，需要时查阅！
zhangkaixuan456的博客
10-14 1398
目录 Future使用 demo CompletableFuture CompletableFuture的优点： demo1:thenApply,进行变换 demo2：thenAccept,获取上一步结果，下一步使用 demo3：thenRun,不管上一步计算结果，直接执行下一步操作 demo4：thenCombine,结合两个异步返回的CompletionStage的结果，进行转换 demo5：结合两个异步返回的CompletionStage的结果，进行转换 demo6：runAfter
CompletableFutureExamples:使用Java的CompletableFuture进行异步编程的示例
05-09
使用Java的进行异步编程的示例
CompletableFuture多任务执行及简单使用场景
06-30
详细的demo
javafuture源码-demo-java-completablefuture:“带有CompletableFuture的Java异步编程”
05-22
future源码Java中具有CompletableFuture的异步编程 介绍 CompletableFuture API是用于Java异步编程的高级API。 该API支持将多个异步计算流水线化（也称为链接或合并）成单个结果，而不会造成嵌套回调（“ callback ...
Java8集合 CompletableFuture lambda表达式 新的TimeAPI 和ForkJoin Demo包
03-19
关于Java8 inAction所有的Demo 非常的实用，全部来自本人亲人编写 放心使用
spring-boot-demo：springboot 2.1+整合各种技术
01-29
：测试spring初始注解：@Async，覆盖串行线程池自定义线程池，无返回值纯初始化，有返回值Future，有返回值CompletableFuture ：整合redis，7大数据类型：string，list，set，zset，hash，geo，hyperloglog ：...
CompletableFuture 多线程流式并发处理任务demo
liu59131065的博客
03-07 295
有些业务很难批量查询，只能去循环查询接口处理业务，可以使用CompletableFuture来创建并发任务配合线程池来处理业务。
java8-Future、CompletableFuture异步处理Demo
进修的CODER
03-16 1212
class Shop { /**异步非阻塞式调用*/ @SuppressWarnings("AlibabaAvoidManuallyCreateThread") public Future&lt;Double&gt; getPriceAsync(String product){ CompletableFuture&lt;Double&gt; futureP...
CompletableFuture 异步编排介绍，附实际应用demo
suitianshuang
10-03 516
异步编排API Amdahl定律 Amdahl加速定律的基本出发点是：1.对于很多科学计算，实时性要求很高，即在此类应用中时间是个关键因素，而计算负载是固定不变的。为此在一定的计算负载下，为达到实时性可利用增加处理器数来提高计算速度；2.因为固定的计算负载是可分布在多个处理器上的，这样增加了处理器就加快了执行速度，从而达到了加速的目的。在此意义下，1967年Amdahl推导出了固定负载的加速公式。 [2] 阿姆达尔定律是计算机系统设计的重要定量原理之一，于1967年由IBM360系列机的主要设计者阿姆达尔
【Java8新特性---＞异步处理】CompletableFuture
qq_52793248的博客
12-23 4102
【Java1.8新特性---＞异步处理】ComplatableFuture
Java并发包之CompletableFuture使用场景以及简单使用(一)
MieMieFly的专栏
09-21 1761
CompletableFuture是Java8提供的一个并发类，方法很多，使用相对复杂。 使用场景：多个线程需要并行或者串行等发杂场景。 先示例一下CompletableFuture的简单场景，上一篇中讲到一个场景是，A和B并行执行，其中结果给C再去执行。 使用CompletableFuture会更简便易于理解。 CompletableFutureDemo.java package com.example.demo.concurrent.completablefuture; import l
JAVA CompletableFuture（异步多线程）真香
詹世炯的博客
04-13 1523
大家好，我是囧叔。欢迎来到小型吹逼现场，如观点请有误请直接喷不需要走流程，拱手作揖。
使用CompletableFuture构建异步应用(1)
lichuangcsdn的博客
06-30 692
public static void main(String[] args) throws Exception { ExecutorService executorService = Executors.newFixedThreadPool(3); ThreadTask threadTask = new ThreadTask(); String name = "1"; ...
并发编程之CompletableFuture全网最细最全用法(一)
Quasimodo24的博客
09-20 4740
并发编程CompletableFuture api 讲解源码解读
多线程CompletableFuture
没有伞的孩子必须努力奔跑！—小林
10-18 1532
自己在项目中使用CompletableFuture比较多，看到很多开源框架中也大量使用到了CompletableFuture。 因此，专门写一篇文章来介绍这个 Java 8 才被引入的一个非常有用的用于异步编程的类。 简单介绍 CompletableFuture同时实现了Future和CompletionStage接口。 public class CompletableFuture<T> implements Future<T>, CompletionSt...
CompletableFuture代码demo
最新发布
07-15
当然，我可以为您提供一个基本的 `CompletableFuture` 代码示例。`CompletableFuture` 是 Java 8 新增的一个类，用于处理异步任务。 下面是一个简单的示例，展示了如何使用 `CompletableFuture` 创建一个异步任务，并在任务完成后获取结果： ```java import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class CompletableFutureDemo { public static void main(String[] args) { // 创建一个CompletableFuture对象 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> { // 模拟一个耗时的操作 try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } return "Hello, CompletableFuture!"; }); // 在任务完成后获取结果 try { String result = future.get(); System.out.println(result); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } } } ``` 在上面的示例中，我们使用 `CompletableFuture.supplyAsync()` 方法创建一个异步任务，该任务会在一个新的线程中执行，并返回一个结果。在这个例子中，我们模拟了一个耗时的操作，等待2秒后返回结果字符串。 然后，我们使用 `future.get()` 方法来获取异步任务的结果。这个方法会阻塞当前线程，直到任务完成并返回结果。 请注意，这只是 `CompletableFuture` 的基本用法示例。`CompletableFuture` 还提供了许多其他方法，如链式调用、异常处理、组合等功能，可以根据具体需求进行使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值