CompletableFuture实现异步编排全面分析和总结

最新推荐文章于 2024-09-06 15:14:26 发布
最新推荐文章于 2024-09-06 15:14:26 发布
阅读量324 收藏 2
点赞数
分类专栏： 多线程与高并发 文章标签： python java 数据库
原文链接：https://zhuanlan.zhihu.com/p/623036273
版权

一、 CompletableFuture简介
CompletableFuture结合了Future的优点，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。

CompletableFuture被设计在Java中进行异步编程。异步编程意味着在主线程之外创建一个独立的线程，与主线程分隔开，并在上面运行一个非阻塞的任务，然后通知主线程进展，成功或者失败。

CompletableFuture是由Java8引入的，在Java8之前我们一般通过Future实现异步。
Future用于表示异步计算的结果，只能通过阻塞或者轮询的方式获取结果，而且不支持设置回调方法，Java8之前若要设置回调一般会使用guava的ListenableFuture。 CompletableFuture对Future进行了扩展，可以通过设置回调的方式处理计算结果，同时也支持组合操作，支持进一步的编排，同时一定程度解决了回调地狱的问题。

二、CompletableFuture 核心接口API介绍
2.1 Future
使用Future局限性
从本质上说，Future表示一个异步计算的结果。它提供了isDone()来检测计算是否已经完成，并且在计算结束后，可以通过get()方法来获取计算结果。在异步计算中，Future确实是个非常优秀的接口。但是，它的本身也确实存在着许多限制：

  • 并发执行多任务：Future只提供了get()方法来获取结果，并且是阻塞的。所以，除了等待你别无他法；
  • 无法对多个任务进行链式调用：如果你希望在计算任务完成后执行特定动作，比如发邮件，但Future却没有提供这样的能力；
  • 无法组合多个任务：如果你运行了10个任务，并期望在它们全部执行结束后执行特定动作，那么在Future中这是无能为力的；
  • 没有异常处理：Future接口中没有关于异常处理的方法；
    在这里插入图片描述
    2.2 CompletableFuture
public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {

}

JDK1.8 才新加入的一个实现类CompletableFuture，而CompletableFuture实现了两个接口（如上面代码所示）：Future、CompletionStage，意味着可以像以前一样通过阻塞或者轮询的方式获得结果。

Future表示异步计算的结果，CompletionStage用于表示异步执行过程中的一个步骤Stage，这个步骤可能是由另外一个CompletionStage触发的，随着当前步骤的完成，也可能会触发其他一系列CompletionStage的执行。从而我们可以根据实际业务对这些步骤进行多样化的编排组合，CompletionStage接口正是定义了这样的能力，我们可以通过其提供的thenAppy、thenCompose等函数式编程方法来组合编排这些步骤。

CompletableFuture是Future接口的扩展和增强。

  • CompletableFuture实现了Future接口，并在此基础上进行了丰富地扩展，完美地弥补了Future上述的种种问题。更为重要的是，
  • CompletableFuture实现了对任务的编排能力。借助这项能力，我们可以轻松地组织不同任务的运行顺序、规则以及方式。从某种程度上说，这项能力是它的核心能力。而在以往，虽然通过CountDownLatch等工具类也可以实现任务的编排，但需要复杂的逻辑处理，不仅耗费精力且难以维护。
    2.3 CompletionStage
    在这里插入图片描述
    CompletionStage接口提供了更多方法来更好的实现异步编排，并且大量的使用了JDK8引入的函数式编程概念。由stage执行的计算可以表示为Function，Consumer或Runnable（使用名称分别包括apply 、accept或run的方法 ），具体取决于它是否需要参数和/或产生结果。 例如：
stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun(() -> System.out.println());

三、使用CompletableFuture场景

3.1 应用场景
1️⃣ 执行比较耗时的操作时，尤其是那些依赖一个或多个远程服务的操作，使用异步任务可以改善程序的性能，加快程序的响应速度；
2️⃣ 使用CompletableFuture类，它提供了异常管理的机制，让你有机会抛出、管理异步任务执行种发生的异常；
3️⃣ 如果这些异步任务之间相互独立，或者他们之间的的某一些的结果是另一些的输入，你可以讲这些异步任务构造或合并成一个。

举个常见的案例 ，在APP查询首页信息的时候，一般会涉及到不同的RPC远程调用来获取很多用户相关信息数据，比如：商品banner轮播图信息、用户message消息信息、用户权益信息、用户优惠券信息 等，假设每个rpc invoke()耗时是250ms，那么基于同步的方式获取到话，算下来接口的RT至少大于1s，这响应时长对于首页来说是万万不能接受的，因此，我们这种场景就可以通过多线程异步的方式去优化。

在这里插入图片描述
3.2 CompletableFuture依赖链分析
根据CompletableFuture依赖数量，可以分为以下几类：零依赖、单依赖、双重依赖和多重依赖 。
在这里插入图片描述
零依赖
下图Future1、Future2都是零依赖的体现：

在这里插入图片描述
单依赖：仅依赖于一个CompletableFuture
下图Future3、Future5都是单依赖的体现，分别依赖于Future1和Future2：
在这里插入图片描述
双重依赖：同时依赖于两个CompletableFuture
下图Future4即为双重依赖的体现，同时依赖于Future1和Future2：
在这里插入图片描述
多重依赖：同时依赖于多个CompletableFuture
下图Future6即为多重依赖的体现，同时依赖于Future3、Future4和Future5：
在这里插入图片描述
类似这种多重依赖的流程来说，结果依赖于三个步骤：Future3、Future4、Future5，这种多元依赖可以通过allOf()或anyOf()方法来实现，区别是当需要多个依赖全部完成时使用allOf()，当多个依赖中的任意一个完成即可时使用anyOf()，如下代码所示：

CompletableFuture<Void> Future6 = CompletableFuture.allOf(Future3, Future4, Future5);
CompletableFuture<String> result = Future6.thenApply(v -> {
    //这里的join并不会阻塞，因为传给thenApply的函数是在Future3、Future4、Future5全部完成时，才会执行 。
    result3 = Future3.join();
    result4 = Future4.join();
    result5 = Future5.join();
    
    // 返回result3、result4、result5组装后结果
    return assamble(result3, result4, result5);
});

四、CompletableFuture异步编排
在分析CompletableFuture异步编排之前，我跟大家理清一下CompletionStage接口下 （thenRun、thenApply、thenAccept、thenCombine、thenCompose）、（handle、whenComplete、exceptionally） 相关方法的实际用法和它们之间的区别是什么? 带着你的想法 往下看吧!!!

4.1 《异步编排API》

  • thenRun：【执行】直接开启一个异步线程执行任务，不接收任何参数，回调方法没有返回值；
  • thenApply：【提供】可以提供返回值，接收上一个任务的执行结果，作为下一个Future的入参，回调方法是有返回值的；
  • thenAccept：【接收】可以接收上一个任务的执行结果，作为下一个Future的入参，回调方法是没有返回值的；
  • thenCombine：【结合】可以结合不同的Future的返回值，做为下一个Future的入参，回调方法是有返回值的；
  • thenCompose：【组成】将上一个Future实例结果传递给下一个实例中。

✔异步回调建议使用自定义线程池

/**
 * 线程池配置
 *
 * @author: austin
 * @since: 2023/3/12 1:32
 */
@Configuration
public class ThreadPoolConfig {

    /**
     * @Bean中声明的value不能跟定义的实例同名
     *
     */
    @Bean(value = "customAsyncTaskExecutor")
    public ThreadPoolTaskExecutor asyncThreadPoolExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(5);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.setQueueCapacity(2048);
        threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        threadPoolTaskExecutor.setThreadNamePrefix("customAsyncTaskExecutor-");
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return threadPoolTaskExecutor;
    }

    @Bean(value = "threadPoolExecutor")
    public ThreadPoolExecutor threadPoolExecutor() {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 60L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10000), new ThreadPoolExecutor.CallerRunsPolicy());
        return threadPoolExecutor;
    }
}

如果所有异步回调都会共用该CommonPool，核心与非核心业务都竞争同一个池中的线程，很容易成为系统瓶颈。手动传递线程池参数可以更方便的调节参数，并且可以给不同的业务分配不同的线程池，以求资源隔离，减少不同业务之间的相互干扰。所以，强烈建议你要根据不同的业务类型创建不同的线程池，以避免互相干扰。通过自定义线程池customAsyncTaskExecutor，后面不同的异步编排方法，我们可以通过指定对应的线程池。

1️⃣ runAsync()、thenRun()

@RestController
public class CompletableFutureCompose {

    @Resource
    private ThreadPoolTaskExecutor customAsyncTaskExecutor;

    @RequestMapping(value = "/thenRun")
    public void thenRun() {
        CompletableFuture.runAsync(() -> {
            System.out.println("thread name:" + Thread.currentThread().getName() + " first step...");
        }, customAsyncTaskExecutor).thenRun(() -> {
            System.out.println("thread name:" + Thread.currentThread().getName() + " second step...");
        }).thenRunAsync(() -> {
            System.out.println("thread name:" + Thread.currentThread().getName() + " third step...");
        });
    }
}

接口输出结果：

thread name:customAsyncTaskExecutor-1 first step...
thread name:customAsyncTaskExecutor-1 second step...
thread name:ForkJoinPool.commonPool-worker-3 third step...

2️⃣ thenApply()

@RequestMapping(value = "/thenApply")
public void thenApply() {
    CompletableFuture.supplyAsync(() -> {
        System.out.println("thread name:" + Thread.currentThread().getName() + " first step...");
        return "hello";
    }, customAsyncTaskExecutor).thenApply((result1) -> {
        String targetResult = result1 + " austin";
        System.out.println("first step result: " + result1);
        System.out.println("thread name:" + Thread.currentThread().getName() + " second step..., targetResult: " + targetResult);
        return targetResult;
    });
}

接口输出结果：

thread name:customAsyncTaskExecutor-2 first step...
first step result: hello
// thenApply虽然没有指定线程池，但是默认是复用它上一个任务的线程池的
thread name:customAsyncTaskExecutor-2 second step..., targetResult: hello austin

3️⃣ thenAccept()

@RequestMapping(value = "/thenAccept")
public void thenAccept() {
    CompletableFuture.supplyAsync(() -> {
        System.out.println("thread name:" + Thread.currentThread().getName() + " first step...");
        return "hello";
    }, customAsyncTaskExecutor).thenAccept((result1) -> {
        String targetResult = result1 + " austin";
        System.out.println("first step result: " + result1);
        System.out.println("thread name:" + Thread.currentThread().getName() + " second step..., targetResult: " + targetResult);
    });
}

接口输出结果：

thread name:customAsyncTaskExecutor-3 first step...
first step result: hello
// thenAccept在没有指定线程池的情况下，并未复用它上一个任务的线程池
thread name:http-nio-10032-exec-9 second step..., targetResult: hello austin

thenAccept()和thenApply()的用法实际上基本上一致，区别在于thenAccept()回调方法是没有返回值的，而thenApply()回调的带返回值的。

细心的朋友可能会发现，上面thenApply()和thenAccept()请求线程池在不指定的情况下，两者的不同表现，thenApply()在不指定线程池的情况下，会沿用上一个Future指定的线程池customAsyncTaskExecutor，而thenAccept()在不指定线程池的情况，并没有复用上一个Future设置的线程池，而是重新创建了新的线程来实现异步调用。

4️⃣ thenCombine()

@RequestMapping(value = "/thenCombine")
public void thenCombine() {
    CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
        System.out.println("执行future1开始...");
        return "Hello";
    }, asyncThreadPoolExecutor);
    CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
        System.out.println("执行future2开始...");
        return "World";
    }, asyncThreadPoolExecutor);
    future1.thenCombine(future2, (result1, result2) -> {
        String result = result1 + " " + result2;
        System.out.println("获取到future1、future2聚合结果：" + result);
        return result;
    }).thenAccept(result -> System.out.println(result));
}

接口访问，打印结果：

thread name:customAsyncTaskExecutor-4 执行future1开始...
thread name:customAsyncTaskExecutor-5 执行future2开始...
thread name:http-nio-10032-exec-8 获取到future1、future2聚合结果：Hello World
Hello World

5️⃣ thenCompose()
我们先有future1，然后和future2组成一个链：future1 -> future2，然后又组合了future3，形成链：future1 -> future2 -> future3。这里有个隐藏的点：future1、future2、future3它们完全没有数据依赖关系，我们只不过是聚合了它们的结果。

@RequestMapping(value = "/thenCompose")
public void thenCompose() {
    CompletableFuture.supplyAsync(() -> {
        // 第一个Future实例结果
        System.out.println("thread name:" + Thread.currentThread().getName() + " 执行future1开始...");
        return "Hello";
    }, customAsyncTaskExecutor).thenCompose(result1 -> CompletableFuture.supplyAsync(() -> {
        // 将上一个Future实例结果传到这里
        System.out.println("thread name:" + Thread.currentThread().getName() + " 执行future2开始..., 第一个实例结果：" + result1);
        return result1 + " World";
    })).thenCompose(result12 -> CompletableFuture.supplyAsync(() -> {
        // 将第一个和第二个实例结果传到这里
        System.out.println("thread name:" + Thread.currentThread().getName() + " 执行future3开始..., 第一第二个实现聚合结果：" + result12);
        String targetResult = result12 + ", I am austin!";
        System.out.println("最终输出结果：" + targetResult);
        return targetResult;
    }));
}

接口访问，打印结果：

thread name:customAsyncTaskExecutor-1 执行future1开始...
thread name:ForkJoinPool.commonPool-worker-3 执行future2开始..., 第一个实例结果：Hello
thread name:ForkJoinPool.commonPool-worker-3 执行future3开始..., 第一第二个实现聚合结果：Hello World
最终输出结果：Hello World, I am austin!

Note：thenCombine() VS thenCompose()，两者之间的区别

  • thenCombine结合的两个CompletableFuture没有依赖关系，且第二个CompletableFuture不需要等第一个CompletableFuture执行完成才开始。
    thenCompose() 可以两个 CompletableFuture
    对象，并将前一个任务的返回结果作为下一个任务的参数，它们之间存在着先后顺序。
  • thenCombine() 会在两个任务都执行完成后，把两个任务的结果合并。两个任务是并行执行的，它们之间并没有先后依赖顺序。

4.2 《CompletableFuture实例化创建》

// 返回一个新的CompletableFuture，由线程池ForkJoinPool.commonPool()中运行的任务异步完成，不会返回结果。
public static CompletableFuture<Void> runAsync(Runnable runnable);
// 返回一个新的CompletableFuture，运行任务时可以指定自定义线程池来实现异步，不会返回结果。
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);

// 返回由线程池ForkJoinPool.commonPool()中运行的任务异步完成的新CompletableFuture，可以返回异步线程执行之后的结果。
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier);
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor);

CompletableFuture有两种方式实现异步，一种是supply开头的方法，一种是run开头的方法：

  • supply 开头：该方法可以返回异步线程执行之后的结果；
  • run 开头：该方法不会返回结果，就只是执行线程任务。

4.3 《获取CompletableFuture结果》

public  T   get()
public  T   get(long timeout, TimeUnit unit)
public  T   getNow(T valueIfAbsent)
public  T   join()
public CompletableFuture<Object> allOf()
public CompletableFuture<Object> anyOf()

使用方式，演示 ：

CompletableFuture<Integer> future = new CompletableFuture<>();
Integer integer = future.get();
  • get()：阻塞式获取执行结果，如果任务还没有完成则会阻塞等待知直到任务执行完成
  • get(long timeout, TimeUnit unit)：带超时的阻塞式获取执行结果
  • getNow()：如果已完成，立刻返回执行结果，否则返回给定的valueIfAbsent
  • join()：该方法和get()方法作用一样， 不抛异常的阻塞式获取异步执行结果
  • allOf()：当给定的所有CompletableFuture都完成时，返回一个新的CompletableFuture
  • anyOf()：当给定的其中一个CompletableFuture完成时，返回一个新的CompletableFuture

Note：
join()和get()方法都是 阻塞式 调用它们的线程（通常为主线程）来获取CompletableFuture异步之后的返回值。 两者的区别在于join()返回计算的结果或者抛出一个unchecked异常CompletionException，而get()返回一个具体的异常。

4.4 《结果处理》
当使用CompletableFuture异步调用计算结果完成、或者是抛出异常的时候，我们可以执行特定的Action做进一步处理，比如：

public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action) 
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action) 
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)

4.5 《异常处理》
使用CompletableFuture编写代码时，异常处理很重要，CompletableFuture提供了三种方法来处理它们：handle()、whenComplete() 和 exceptionly()。

  • handle：返回一个新的CompletionStage，当该阶段正常或异常完成时，将使用此阶段的结果和异常作为所提供函数的参数执行，不会将内部异常抛出。
  • whenComplete：返回与此阶段具有相同结果或异常的新CompletionStage，该阶段在此阶段完成时执行给定操作。与方法handle不同，会将内部异常往外抛出。
  • exceptionally：返回一个新的CompletableFuture，CompletableFuture提供了异常捕获回调exceptionally，相当于同步调用中的try/catch。
@Autowired
private RemoteDictService remoteDictService;

public CompletableFuture<Dict> getDictDataAsync(long dictId) {
    CompletableFuture<DictResult> resultFuture = remoteDictService.findDictById(dictId);
    // 业务方法，内部会发起异步rpc调用
    return resultFuture
            .exceptionally(error -> {
                //通过exceptionally捕获异常，打印日志并返回默认值
                log.error("RemoteDictService.getDictDataAsync Exception dictId = {}", dictId, error);
                return null;
            });
}

handle() VS whenComplete(), 两者之间的区别

  • 核心区别在于whenComplete不消费异常，而handle消费异常
    两种方法形式支持处理触发阶段是否 正常完成 或 异常完成：
  • whenComplete：可以访问当前CompletableFuture的 结果 和 异常
    作为参数，使用它们并执行您想要的操作。此方法并不能转换完成的结果，会内部抛出异常。
  • handle：当此阶段正常或异常完成时，将使用此阶段的结果和异常作为所提供函数的参数来执行。当此阶段完成时，以 该阶段的结果 和
    该阶段的异常 作为参数调用给定函数，并且函数的结果用于完成返回的阶段，不会把异常外抛出来。

这里我通过代码演示一下：

public class CompletableFutureExceptionHandler {

    public static CompletableFuture handle(int a, int b) {
        return CompletableFuture.supplyAsync(() -> a / b)
                .handle((result, ex) -> {
                    if (null != ex) {
                        System.out.println("handle error: " + ex.getMessage());
                        return 0;
                    } else {
                        return result;
                    }
                });
    }

    public static CompletableFuture whenComplete(int a, int b) {
        return CompletableFuture.supplyAsync(() -> a / b)
                .whenComplete((result, ex) -> {
                    if (null != ex) {
                        System.out.println("whenComplete error: " + ex.getMessage());
                    }
                });
    }


    public static void main(String[] args) {
        try {
            System.out.println("success: " + handle(10, 5).get());
            System.out.println("fail: " + handle(10, 0).get());
        } catch (Exception e) {
            System.out.println("catch exception= " + e.getMessage());
        }

        System.out.println("------------------------------------------------------------------");

        try {
            System.out.println("success: " + whenComplete(10, 5).get());
            System.out.println("fail: " + whenComplete(10, 0).get());
        } catch (Exception e) {
            System.out.println("catch exception=" + e.getMessage());
        }
    }
}

运行结果如下显示：

success: 2
handle error: java.lang.ArithmeticException: / by zero
fail: 0
------------------------------------------------------------------
success: 2
whenComplete error: java.lang.ArithmeticException: / by zero
catch exception=java.lang.ArithmeticException: / by zero

✔可以看到，handle处理，当程序发生异常的时候，即便是catch获取异常期望输出，但是并未跟实际预想那样，原因是handle不会把内部异常外抛出来，而whenComplete会将内部异常抛出。

五、CompletableFuture线程池须知
Note：关于异步线程池（十分重要）
异步回调方法可以选择是否传递线程池参数Executor，这里为了实现线程池隔离，当不传递线程池时，默认会使用ForkJoinPool中的公共线程池CommonPool，这个线程池默认创建的线程数是CPU的核数，如果所有的异步回调共享一个线程池，核心与非核心业务都竞争同一个池中的线程，那么一旦有任务执行一些很慢的I/O 操作，就会导致线程池中所有线程都阻塞在I/O操作上，很容易成为系统瓶颈，影响整个系统的性能。因此， 建议强制传线程池，且根据实际情况做线程池隔离，减少不同业务之间的相互干扰。

六、基于CompletableFuture实现接口异步revoke

案例实现Controller层

@RestController
@RequestMapping("/index")
public class IndexWebController {
    @Resource
    private ThreadPoolExecutor asyncThreadPoolExecutor;

    @RequestMapping(value = "/homeIndex", method = {RequestMethod.POST, RequestMethod.GET})
    public String homeIndex(@RequestParam(required = false) String userId, @RequestParam(value = "lang") String lang) {
        ResultData<HomeVO> result = new ResultData<>();
        // 获取Banner轮播图信息
        CompletableFuture<List<BannerVO>> future1 = CompletableFuture.supplyAsync(() -> this.buildBanners(userId, lang), asyncThreadPoolExecutor);
        // 获取用户message通知信息
        CompletableFuture<NotificationVO> future2 = CompletableFuture.supplyAsync(() -> this.buildNotifications(userId, lang), asyncThreadPoolExecutor);
        // 获取用户权益信息
        CompletableFuture<List<BenefitVO>> future3 = CompletableFuture.supplyAsync(() -> this.buildBenefits(userId, lang), asyncThreadPoolExecutor);
         // 获取优惠券信息
        CompletableFuture<List<CouponVO>> future4 = CompletableFuture.supplyAsync(() -> this.buildCoupons(userId), asyncThreadPoolExecutor);
        
        CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(futrue1, futrue2, futrue3, future4);
        HomeVo finalHomeVO = homeVO;
        CompletableFuture<HomeVO> resultFuture = allOfFuture.thenApply(v -> {
            try {
                finalHomeVo.setBanners(future1.get());
                finalHomeVo.setNotifications(future2.get());
                finalHomeVo.setBenefits(future3.get());
                finalHomeVo.setCoupons(future4.get());
                return finalHomeVO;
            } catch (Exception e) {
                logger.error("[Error] assemble homeVO data error: {}", e);
                throw new RuntimeException(e);
            }
        });
        homeVO = resultFuture.join();
        result.setData(homeVO);
        return writeJson(result);
    }
}

Service层

@SneakyThrows
public List<BannerVO> buildBanners(String userId, String lang) {
    // 模拟请求耗时0.5秒
    Thread.sleep(500);
    return new List<BannerVO>();
}

@SneakyThrows
public List<NotificationVO> buildNotifications(String userId, String lang) {
    // 模拟请求耗时0.5秒
    Thread.sleep(500);
    return new List<NotificationVO>();
}

@SneakyThrows
public List<BenefitVO> buildBenefits(String userId, String lang) {
    // 模拟请求耗时0.5秒
    Thread.sleep(500);
    return new List<BenefitVO>();
}

@SneakyThrows
public List<CouponVO> buildCoupons(String userId) {
    // 模拟请求耗时0.5秒
    Thread.sleep(500);
    return new List<CouponVO>();
}

六、异步化带来的性能提升

  • 通过异步化改造，原本同步获取数据的API性能得到明显提升，大大减少了接口的响应时长(RT)。
  • 接口的吞吐量大幅度提升。

七、总结
本篇文章主要是介绍了CompletableFuture使用原理和相关不同方法的场景化使用，以及通过不同的实例演示了异步回调的过程。

蓝天⊙白云
关注
专栏目录
JAVA 1.8新特新 CompletableFuture 的详解
Println_handsome的博客
09-09 572
2.1. 线程回顾 初始化线程的4种方式： 继承Thread 实现Runnable接口 实现Callable接口 + FutureTask （可以拿到返回结果，可以处理异常） 线程池 方式1和方式2：主进程无法获取线程的运算结果。不适合当前场景 方式3：主进程可以获取线程的运算结果，并设置给itemVO，但是不利于控制服务器中的线程资源。可以导致服务器资源耗尽。 方式4：通过如下两种方式初始化线程池： Executors.newFiexedThreadPool(3); //或者 new ThreadPo
并发编程之CompletableFuture异步编排的详细介绍和基本使用（全网最细最全）
m0_56466015的博客
03-20 4412
CompletableFutyre异步编排最详细介绍和所有用法的举例说明（附源码），全网最全最细
CompletableFuture异步编排，你还不会？
最新发布
Maisucsdn的博客
09-06 164
对于不需要返回结果的任务，使用runAsync。对于需要返回结果的任务，使用。在任务完成后，无论是否成功，都要执行某些操作时，使用或。仅在任务发生异常时处理异常并提供替代结果，使用。处理任务结果但不返回新值时，使用thenAccept。处理任务结果并返回新值时，使用thenApply或。根据是否需要异步执行选择同步或异步版本。带Async代表异步，异步就是启动另外线程去执行。有xxpply的就代表有返回值java代码解读复制代码。
CompletableFuture 异步编排
老男孩的架构路
08-16 548
在 Java8 中，新增了 CompletableFuture 异步编程工具类。它与我们之前使用的 Future 接口有何区别呢？本文将对这个重要的 CompletableFuture 类进行分析学习。1、runXxx 都是没有返回结果的，supplyXxx 都是可以获取返回值的；2、可以传入自定义的线程池，否则就用默认的线程池：ForkJoinPool.commonPool()；3、Async 代表异步的意思。2.1 获得结果和触发计算获得结果get() :不见不散。...
CompletableFuture异步编排
qq_48721706的博客
04-19 2017
异步一、线程基本了解1、创建线程的四种方式1.1、继承Thread类1.2、实现Runnable接口1.3、实现Callable接口 + FutureTask (可以拿到返回结果，可以处理异常)1.4、使用线程池2、线程池2.1、线程池七大参数2.2、运行流程2.3、常见的4种线程池特点二、CompletableFuture异步编排1、创建CompletableFuture1.1、runAsync（无返回值）1.2、supplyAsync（有返回值）2、各个方法使用1、`whenComplete`2、`ha
使用JAVA CompletableFuture实现流水线化的并行处理，深度实践总结
Moonxiyue的博客
07-26 4205
好啦，关于JAVA中的使用，以及并行编程相关的内容呢就介绍到这里啦。看到这里，相信您应该有所收获吧？那么你的项目里有这种适合并行处理的场景吗？你在处理并行场景的时候是怎么做的呢？评论区一起讨论下吧~~本文中有提及执行时所使用的默认线程池是，早在JAVA7版本就已经被引入，但是很多人对不是很了解，实际项目中使用的也比较少。其实对的合理利用，可以让我们在面对某些多线程场景时会更加的从容高效。在后面的文章中，我会针对有关的内容进行专门的介绍与探讨，如果有兴趣，可以点个关注，及时获取后续的内容。https。...
【Java.lang Thread类与Python并发模型对比】：线程管理和并发控制的深入分析
[【Java.lang Thread类与Python并发模型对比】：线程管理和并发控制的深入分析](https://img-blog.csdnimg.cn/20200411101732453.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0...
【提升应用响应速度】：Spring Boot中的异步处理秘籍
为了提高用户体验和系统吞吐量，异步处理成为解决这一挑战的重要手段。在Spring Boot中，异步处理提供了一种高效的方法来优化应用性能，将耗时的任务从主线程中移出，从而不阻塞主线程，使得系统能够更快地处理并发...
CompletableFuture: 异步编排
yubin1285570923的博客
04-27 276
一、CompletableFuture 1 异步编排，可以编配任务执行，与vue的promise类似。 futrue可以获取异步任务的结果 1 public static CompletableFuture<Void> runAsync(Runnable runnable) { return asyncRunStage(asyncPool, runnable); } 2 public static CompletableFuture<Void&gt
CompletableFuture异步编排+实战
Knight
02-02 1626
Future是Java 5添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel方法停止任务的执行。在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。
completablefuture 异步编排
07-19
1. **链式调用**：CompletableFuture 提供了 `.thenApply()`, `.thenAccept()`, 和 `.thenCompose()` 等方法，允许程序员通过链式调用的方式将多个异步操作串联起来，形成一个任务序列。 2. **并发处理**：你可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值