范文健康探索娱乐情感热点
投稿投诉
热点动态
科技财经
情感日志
励志美文
娱乐时尚
游戏搞笑
探索旅游
历史星座
健康养生
美丽育儿
范文作文
教案论文
国学影视
热点动态科技财经
焦点资讯时事国际环球新闻

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

　　一、CompletableFuture简介CompletableFuture结合了Future的优点，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。
　　CompletableFuture被设计在Java中进行异步编程。异步编程意味着在主线程之外创建一个独立的线程，与主线程分隔开，并在上面运行一个非阻塞的任务，然后通知主线程进展，成功或者失败。
　　CompletableFuture是由Java8引入的，在Java8之前我们一般通过Future实现异步。
　　Future用于表示异步计算的结果，只能通过阻塞或者轮询的方式获取结果，而且不支持设置回调方法，Java8之前若要设置回调一般会使用guava的ListenableFuture。 CompletableFuture对Future进行了扩展，可以通过设置回调的方式处理计算结果，同时也支持组合操作，支持进一步的编排，同时一定程度解决了回调地狱的问题。✔本文的名词缩写：CF：代表CompletableFutureCS：代表CompletionStage二、CompletableFuture 核心接口API介绍2.1 Future使用Future局限性
　　从本质上说，Future表示一个异步计算的结果。它提供了isDone()来检测计算是否已经完成，并且在计算结束后，可以通过get()方法来获取计算结果。在异步计算中，Future确实是个非常优秀的接口。但是，它的本身也确实存在着许多限制：并发执行多任务：Future只提供了get()方法来获取结果，并且是阻塞的。所以，除了等待你别无他法；无法对多个任务进行链式调用：如果你希望在计算任务完成后执行特定动作，比如发邮件，但Future却没有提供这样的能力；无法组合多个任务：如果你运行了10个任务，并期望在它们全部执行结束后执行特定动作，那么在Future中这是无能为力的；没有异常处理：Future接口中没有关于异常处理的方法；
　　方法
　　说明
　　描述
　　boolean
　　cancel (boolean mayInterruptIfRunning)
　　尝试取消执行此任务。
　　V
　　get()
　　如果需要等待计算完成，然后检索其结果。
　　V
　　get(long timeout, TimeUnit unit)
　　如果需要，最多等待计算完成的给定时间，然后检索其结果（如果可用）。
　　boolean
　　isCancelled()
　　如果此任务在正常完成之前取消，则返回 true 。
　　boolean
　　isDone()
　　如果此任务完成，则返回 true 。2.2 CompletableFuturepublic class CompletableFuture implements Future, CompletionStage {  }
　　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 Future6 = CompletableFuture.allOf(Future3, Future4, Future5); CompletableFuture 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 austin3️⃣ 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 future1 = CompletableFuture.supplyAsync(() -> {         System.out.println(＂执行future1开始...＂);         return ＂Hello＂;     }, asyncThreadPoolExecutor);     CompletableFuture 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 World5️⃣ 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 runAsync(Runnable runnable); // 返回一个新的CompletableFuture，运行任务时可以指定自定义线程池来实现异步，不会返回结果。 public static CompletableFuture runAsync(Runnable runnable, Executor executor);  // 返回由线程池ForkJoinPool.commonPool()中运行的任务异步完成的新CompletableFuture，可以返回异步线程执行之后的结果。 public static  CompletableFuture supplyAsync(Supplier supplier); public static  CompletableFuture supplyAsync(Supplier 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 allOf() public CompletableFuture anyOf()
　　使用方式，演示：CompletableFuture future = new CompletableFuture<>(); Integer integer = future.get();get()：阻塞式获取执行结果，如果任务还没有完成则会阻塞等待知直到任务执行完成get(long timeout, TimeUnit unit)：带超时的阻塞式获取执行结果getNow()：如果已完成，立刻返回执行结果，否则返回给定的valueIfAbsentjoin()：该方法和get()方法作用一样， 不抛异常的阻塞式获取异步执行结果allOf()：当给定的所有CompletableFuture都完成时，返回一个新的CompletableFutureanyOf()：当给定的其中一个CompletableFuture完成时，返回一个新的CompletableFutureNote：
　　join()和get()方法都是 阻塞式 调用它们的线程（通常为主线程）来获取CompletableFuture异步之后的返回值。 两者的区别在于join()返回计算的结果或者抛出一个unchecked异常CompletionException，而get()返回一个具体的异常。4.4 《结果处理》
　　当使用CompletableFuture异步调用计算结果完成、或者是抛出异常的时候，我们可以执行特定的Action做进一步处理，比如：public CompletableFuture whenComplete(BiConsumer<? super T,? super Throwable> action)  public CompletableFuture whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)  public CompletableFuture 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 getDictDataAsync(long dictId) {     CompletableFuture 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消费异常Two method forms support processing whether the triggering stage completed normally or exceptionally:
　　Method {whenComplete} allows injection of an action regardless of outcome, otherwise preserving the outcome in its completion.
　　Method {handle} additionally allows the stage to compute a replacement result that may enable further processing by other dependent stages.
　　翻译过来就是：
　　两种方法形式支持处理触发阶段是否 正常完成 或 异常完成：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 result = new ResultData<>();         // 获取Banner轮播图信息         CompletableFuture> future1 = CompletableFuture.supplyAsync(() -> this.buildBanners(userId, lang), asyncThreadPoolExecutor);         // 获取用户message通知信息         CompletableFuture future2 = CompletableFuture.supplyAsync(() -> this.buildNotifications(userId, lang), asyncThreadPoolExecutor);         // 获取用户权益信息         CompletableFuture> future3 = CompletableFuture.supplyAsync(() -> this.buildBenefits(userId, lang), asyncThreadPoolExecutor);          // 获取优惠券信息         CompletableFuture> future4 = CompletableFuture.supplyAsync(() -> this.buildCoupons(userId), asyncThreadPoolExecutor);                  CompletableFuture allOfFuture = CompletableFuture.allOf(futrue1, futrue2, futrue3, future4);         HomeVo finalHomeVO = homeVO;         CompletableFuture 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 buildBanners(String userId, String lang) {     // 模拟请求耗时0.5秒     Thread.sleep(500);     return new List(); }  @SneakyThrows public List buildNotifications(String userId, String lang) {     // 模拟请求耗时0.5秒     Thread.sleep(500);     return new List(); }  @SneakyThrows public List buildBenefits(String userId, String lang) {     // 模拟请求耗时0.5秒     Thread.sleep(500);     return new List(); }  @SneakyThrows public List buildCoupons(String userId) {     // 模拟请求耗时0.5秒     Thread.sleep(500);     return new List(); }六、异步化带来的性能提升通过异步化改造，原本同步获取数据的API性能得到明显提升，大大减少了接口的响应时长(RT)。接口的吞吐量大幅度提升。


预算五千左右买台台式电脑自己组装能多开玩游戏和大型游戏怎么配？现在玩游戏配电脑属于不理智！因为显卡这两年已经处在高位上，拿玩游戏性价比最高的1660ti举例（除了没光追性能跟2060差距在510），在挖矿未开始的时候也就1500元左右，但目前为什么英雄联盟吧和LOL吧不合并？楼上都是扯淡，放一堆合并规则出来屁用没有，内测玩家告诉你，当时我是两个吧都10级，然后有一个吧吧主是封寒江，她自己说的是百度不愿意合并，不愿意损失这部分流量和数据。有答案说是因为利有哪些挂机类单机手机游戏值得推荐？这里是喜爱游戏的小白放置类游戏，顾名思义，是一种只需要把游戏放在那里，游戏就会根据系统的一系列运算规则自动运行并得到游戏结果的游戏类型。其实这类游戏大多都是以页游的方式存在，放置游英雄联盟官方为保护一个人而将该英雄的玩家称呼变成禁词，这个英雄是谁，你怎么看？理性游戏，拒绝沉迷英雄联盟已经运营八年了，现在可以说是国际影响力最大的游戏了吧。也是因为这款游戏才加速了电竞体育的发展的，而在世界范围内影响力这么大的游戏一旦出现一些被别人恶意中伤农村卫星电视接收器的位置信息改变了，该怎么调？大家好！我来回答这个问题，我们村一百多台户户通电视接收器都是我一个人按装的，对于这个问题我是最了解的！电视接收器也叫机顶盒，其实，出现电视接收器位置信息改变有两种原因，一种是你确实DOPA排到炫神，被队友一句话逗乐，炫神瞎子帮Dopa抓中遭问号攻击，什么梗？想我当年西北砍王一世瞎子，却被Dopa一句话给自闭多年，现在不做直播好多年，而直播界依然流传着banxiazi的梗，砍王也是绝对算的上是人才了，玩瞎子也是可以菜到一定的境界的。在最贾森基德是如何让独行侠的防守从联盟第20名，上升到联盟第5的？这要从基德个人经历说起，基德是94年NBA选秀第一轮第二顺位被独行侠当时还叫小牛队选中，自此开启了一段属于他的传奇NBA生涯。接下来我们看下基德球员时期所获得的一些荣誉，95年最佳朱婷张常宁相继手术，估计难恢复当年之勇，女排还有冠军希望吗？希望一定有，英雄辈出嘛，任何英雄都注定不是该事业的最后巅峰中国女排当然有冠军希望，目前中国女排仍然是世界強队，仍然具有强大的攻击力，朱婷张常宁伤愈后完全可以保持高水平，加上巳成熟进为啥很多足球队要退出中超，中超难道要解散了吗？房地产行业崩溃没有资金玩了或者人家盆满钵满了，足球和资本挂钩，没有钱当然不玩那倒不会，作为世界第一运动，无论国家，还是百姓，都不能容许专业足球比赛在中国消失。中国足球运动的最高级联南非离发达国家只差一步之遥，为何就倒车了？一步之遥个锤子，当年南非距离真正的发达国家，还差十万八千里。在很多人眼里，南非曾是非洲唯一的发达国家，但是因为曼德拉让黑人掌管了南非，使得整个国家陷入了长期的衰退，所以变成了如今的为什么抖音里面的人过得特别好，头条里面的人全是负债？本文来自微信公众号全天候科技（IDiawtmt），作者胡描，编辑罗丽娟，头图来自ICphoto11月2日，字节跳动CEO梁汝波发布全员邮件，宣布调整组织架构，实行业务线BU化（Bu


<<<<<<－>>>>>>


阿里巴巴形成党委领导下的总经理负责制？请停止网络炒作！近日有不少信息称阿里巴巴将会于2023年成立3个党委总部，设立25个二级党组织，150多个党支部，可事实真的如此吗？我们不妨先上网搜索一下信息来源，从时间线上来看最早是由一家中文名宇宙我们知道的宇宙，并不是现在探知到的宇宙，而是包括在内，以及可知宇宙之外的地方，大可以大胆一些，妙论也好？猜想也罢？知之为知之，不知为不知，是知也！无神论，科学论，神学论，交织在一起对普通人来说，资本市场意味着什么？最为人所熟知的资本市场无疑是股市。截止到2022年年底，A股股民人数超过了2亿人，是全国人口的七分之一。如果算上间接参与投资股市的基民，人数还会翻好几倍。而无论对谁说，股市本质都是别克新车标1。5T四缸溜背式的昂扬能够和途岳逍客抢市场？低重心的外表，流畅动感的线条，就算不捂住车标，问你这是什么车，很多人也未必会知道。昂扬来自上汽通用别克。除了与昂科拉昂科威昂科旗都姓昂以外，你找不出它们之间任何的家族式联系。毕竟昂2023年东南亚跨境电商市场现状及发展前景在欧美电商市场逐渐趋于饱和的情况下，中国卖家正在寻求新的蓝海。毫无疑问，2023年，东南亚是最热门的跨境电商市场。东南亚是世界上增长最快潜力最大的蓝海，吸引了很多大公司加入，Tik分析2023年折叠屏手机会成为市场主流吗？（本文系紫金财经原创稿件，转载请注明来源）在2023年伊始，这个疫情之后的冬天虽然寒冷，但人们饱含对未来的希望，各行各业都在回顾过去，同时展望未来。对于全球智能手机行业而言，2022022年加密货币市场大事件，哪些对你影响最大？来源CoinsBench作者MEXCResearch2022年对于加密行业来说是意想不到的一年。从年初近3万亿的市值峰值一路走低。在全球货币紧缩和疫情的复杂背景下，LUNA崩盘，F你好，2023SoulAppCTO陶明实现社交资产价值，为用户创造更酷的社交体验2023年，被业内预测为经济的拐点年份。全球新一轮科技革命和产业革命正逐步深入，数字产业化正对相关产业进行数字革新。更多的新科技新制造新消费公司也在新浪潮下，不断成长。对Soul来NBA公认的5大肌肉男，詹姆斯堪称人类标本马龙手臂像充气NBA肌肉男真不少，毕竟想在这里混饭吃，身体是第一位。没有身体，哪怕你有最完美的技术，那也是施展不出来。想要拥有强人一等的肌肉，那除了足够刻苦和自律之外，自身的天赋也重要，没有出色科技巨头开年15天裁员2。5万人！硅谷陷寒冬，每天1600人失业编辑昕朋新智元导读科技行业的裁员潮席卷全球！15天内，2万4千多名员工被解雇。面对经济寒冬，科技公司使出浑身解数，却都纷纷破防不想裁员，但真的顶不住了！2023年，科技行业的裁员浪篮球世界，还相信詹姆斯吗当詹姆斯在背靠背的比赛中砍下赛季新高的48分8篮板9助攻，并且全场没有出现失误时，媒体关注的焦点并不是38岁的詹姆斯为何能保持这样的状态，而是一段他和火箭球员小贾巴里史密斯的对话。