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

　　一、CompletableFuture简介CompletableFuture结合了Future的优点，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。
　　CompletableFuture被设计在Java中进行异步编程。异步编程意味着在主线程之外创建一个独立的线程，与主线程分隔开，并在上面运行一个非阻塞的任务，然后通知主线程进展，成功或者失败。
　　CompletableFuture是由Java8引入的，在Java8之前我们一般通过Future实现异步。
　　Future用于表示异步计算的结果，只能通过阻塞或者轮询的方式获取结果，而且不支持设置回调方法，Java8之前若要设置回调一般会使用guava的ListenableFuture。CompletableFuture对Future进行了扩展，可以通过设置回调的方式处理计算结果，同时也支持组合操作，支持进一步的编排，同时一定程度解决了回调地狱的问题。本文的名词缩写：CF：代表CompletableFutureCS：代表CompletionStage二、CompletableFuture核心接口API介绍2。1Future使用Future局限性
　　从本质上说，Future表示一个异步计算的结果。它提供了isDone（）来检测计算是否已经完成，并且在计算结束后，可以通过get（）方法来获取计算结果。在异步计算中，Future确实是个非常优秀的接口。但是，它的本身也确实存在着许多限制：并发执行多任务：Future只提供了get（）方法来获取结果，并且是阻塞的。所以，除了等待你别无他法；无法对多个任务进行链式调用：如果你希望在计算任务完成后执行特定动作，比如发邮件，但Future却没有提供这样的能力；无法组合多个任务：如果你运行了10个任务，并期望在它们全部执行结束后执行特定动作，那么在Future中这是无能为力的；没有异常处理：Future接口中没有关于异常处理的方法；
　　方法
　　说明
　　描述
　　boolean
　　cancel（booleanmayInterruptIfRunning）
　　尝试取消执行此任务。
　　V
　　get（）
　　如果需要等待计算完成，然后检索其结果。
　　V
　　get（longtimeout，TimeUnitunit）
　　如果需要，最多等待计算完成的给定时间，然后检索其结果（如果可用）。
　　boolean
　　isCancelled（）
　　如果此任务在正常完成之前取消，则返回true。
　　boolean
　　isDone（）
　　如果此任务完成，则返回true。2。2CompletableFuturepublicclassCompletableFutureTimplementsFutureT，CompletionStageT｛｝
　　JDK1。8才新加入的一个实现类CompletableFuture，而CompletableFuture实现了两个接口（如上面代码所示）：Future、CompletionStagestrongem，意味着可以像以前一样通过阻塞或者轮询的方式获得结果。
　　Future表示异步计算的结果，CompletionStage用于表示异步执行过程中的一个步骤Stage，这个步骤可能是由另外一个CompletionStage触发的，随着当前步骤的完成，也可能会触发其他一系列CompletionStage的执行。从而我们可以根据实际业务对这些步骤进行多样化的编排组合，CompletionStage接口正是定义了这样的能力，我们可以通过其提供的thenAppy、thenCompose等函数式编程方法来组合编排这些步骤。CompletableFuture是Future接口的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富地扩展，完美地弥补了Future上述的种种问题。更为重要的是，CompletableFuture实现了对任务的编排能力。借助这项能力，我们可以轻松地组织不同任务的运行顺序、规则以及方式。从某种程度上说，这项能力是它的核心能力。而在以往，虽然通过CountDownLatch等工具类也可以实现任务的编排，但需要复杂的逻辑处理，不仅耗费精力且难以维护。2。3CompletionStage
　　CompletionStage接口提供了更多方法来更好的实现异步编排，并且大量的使用了JDK8引入的函数式编程概念。由stage执行的计算可以表示为Function，Consumer或Runnable（使用名称分别包括apply、accept或run的方法），具体取决于它是否需要参数和或产生结果。例如：stage。thenApply（xsquare（x））。thenAccept（xSystem。out。print（x））。thenRun（（）System。out。println（））；三、使用CompletableFuture场景3。1应用场景
　　1执行比较耗时的操作时，尤其是那些依赖一个或多个远程服务的操作，使用异步任务可以改善程序的性能，加快程序的响应速度；
　　2使用CompletableFuture类，它提供了异常管理的机制，让你有机会抛出、管理异步任务执行种发生的异常；
　　3如果这些异步任务之间相互独立，或者他们之间的的某一些的结果是另一些的输入，你可以讲这些异步任务构造或合并成一个。
　　举个常见的案例，在APP查询首页信息的时候，一般会涉及到不同的RPC远程调用来获取很多用户相关信息数据，比如：商品banner轮播图信息、用户message消息信息、用户权益信息、用户优惠券信息等，假设每个rpcinvoke（）耗时是250ms，那么基于同步的方式获取到话，算下来接口的RT至少大于1s，这响应时长对于首页来说是万万不能接受的，因此，我们这种场景就可以通过多线程异步的方式去优化。
　　3。2CompletableFuture依赖链分析
　　根据CompletableFuture依赖数量，可以分为以下几类：零依赖、单依赖、双重依赖和多重依赖。
　　零依赖
　　下图Future1、Future2都是零依赖的体现：
　　单依赖：仅依赖于一个CompletableFuture
　　下图Future3、Future5都是单依赖的体现，分别依赖于Future1和Future2：
　　双重依赖：同时依赖于两个CompletableFuture
　　下图Future4即为双重依赖的体现，同时依赖于Future1和Future2：
　　多重依赖：同时依赖于多个CompletableFuture
　　下图Future6即为多重依赖的体现，同时依赖于Future3、Future4和Future5：
　　类似这种多重依赖的流程来说，结果依赖于三个步骤：Future3、Future4、Future5，这种多元依赖可以通过allOf（）或anyOf（）方法来实现，区别是当需要多个依赖全部完成时使用allOf（），当多个依赖中的任意一个完成即可时使用anyOf（），如下代码所示：CompletableFutureVoidFuture6CompletableFuture。allOf（Future3，Future4，Future5）；CompletableFutureStringresultFuture6。thenApply（v｛这里的join并不会阻塞，因为传给thenApply的函数是在Future3、Future4、Future5全部完成时，才会执行。result3Future3。join（）；result4Future4。join（）；result5Future5。join（）；返回result3、result4、result5组装后结果returnassamble（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：austinsince：20233121：32ConfigurationpublicclassThreadPoolConfig｛Bean中声明的value不能跟定义的实例同名Bean（valuecustomAsyncTaskExecutor）publicThreadPoolTaskExecutorasyncThreadPoolExecutor（）｛ThreadPoolTaskExecutorthreadPoolTaskExecutornewThreadPoolTaskExecutor（）；threadPoolTaskExecutor。setCorePoolSize（5）；threadPoolTaskExecutor。setMaxPoolSize（10）；threadPoolTaskExecutor。setKeepAliveSeconds（60）；threadPoolTaskExecutor。setQueueCapacity（2048）；threadPoolTaskExecutor。setWaitForTasksToCompleteOnShutdown（true）；threadPoolTaskExecutor。setThreadNamePrefix（customAsyncTaskExecutor）；threadPoolTaskExecutor。setRejectedExecutionHandler（newThreadPoolExecutor。CallerRunsPolicy（））；returnthreadPoolTaskExecutor；｝Bean（valuethreadPoolExecutor）publicThreadPoolExecutorthreadPoolExecutor（）｛ThreadPoolExecutorthreadPoolExecutornewThreadPoolExecutor（10，10，60L，TimeUnit。SECONDS，newArrayBlockingQueue（10000），newThreadPoolExecutor。CallerRunsPolicy（））；returnthreadPoolExecutor；｝｝
　　如果所有异步回调都会共用该CommonPool，核心与非核心业务都竞争同一个池中的线程，很容易成为系统瓶颈。手动传递线程池参数可以更方便的调节参数，并且可以给不同的业务分配不同的线程池，以求资源隔离，减少不同业务之间的相互干扰。所以，强烈建议你要根据不同的业务类型创建不同的线程池，以避免互相干扰。通过自定义线程池customAsyncTaskExecutor，后面不同的异步编排方法，我们可以通过指定对应的线程池。1runAsync（）、thenRun（）RestControllerpublicclassCompletableFutureCompose｛ResourceprivateThreadPoolTaskExecutorcustomAsyncTaskExecutor；RequestMapping（valuethenRun）publicvoidthenRun（）｛CompletableFuture。runAsync（（）｛System。out。println（threadname：Thread。currentThread（）。getName（）firststep。。。）；｝，customAsyncTaskExecutor）。thenRun（（）｛System。out。println（threadname：Thread。currentThread（）。getName（）secondstep。。。）；｝）。thenRunAsync（（）｛System。out。println（threadname：Thread。currentThread（）。getName（）thirdstep。。。）；｝）；｝｝
　　接口输出结果：threadname：customAsyncTaskExecutor1firststep。。。threadname：customAsyncTaskExecutor1secondstep。。。threadname：ForkJoinPool。commonPoolworker3thirdstep。。。2thenApply（）RequestMapping（valuethenApply）publicvoidthenApply（）｛CompletableFuture。supplyAsync（（）｛System。out。println（threadname：Thread。currentThread（）。getName（）firststep。。。）；returnhello；｝，customAsyncTaskExecutor）。thenApply（（result1）｛StringtargetResultresult1austin；System。out。println（firststepresult：result1）；System。out。println（threadname：Thread。currentThread（）。getName（）secondstep。。。，targetResult：targetResult）；returntargetResult；｝）；｝
　　接口输出结果：threadname：customAsyncTaskExecutor2firststep。。。firststepresult：hellothenApply虽然没有指定线程池，但是默认是复用它上一个任务的线程池的threadname：customAsyncTaskExecutor2secondstep。。。，targetResult：helloaustin3thenAccept（）RequestMapping（valuethenAccept）publicvoidthenAccept（）｛CompletableFuture。supplyAsync（（）｛System。out。println（threadname：Thread。currentThread（）。getName（）firststep。。。）；returnhello；｝，customAsyncTaskExecutor）。thenAccept（（result1）｛StringtargetResultresult1austin；System。out。println（firststepresult：result1）；System。out。println（threadname：Thread。currentThread（）。getName（）secondstep。。。，targetResult：targetResult）；｝）；｝
　　接口输出结果：threadname：customAsyncTaskExecutor3firststep。。。firststepresult：hellothenAccept在没有指定线程池的情况下，并未复用它上一个任务的线程池threadname：httpnio10032exec9secondstep。。。，targetResult：helloaustin
　　thenAccept（）和thenApply（）的用法实际上基本上一致，区别在于thenAccept（）回调方法是没有返回值的，而thenApply（）回调的带返回值的。
　　细心的朋友可能会发现，上面thenApply（）和thenAccept（）请求线程池在不指定的情况下，两者的不同表现，thenApply（）在不指定线程池的情况下，会沿用上一个Future指定的线程池customAsyncTaskExecutor，而thenAccept（）在不指定线程池的情况，并没有复用上一个Future设置的线程池，而是重新创建了新的线程来实现异步调用。4thenCombine（）RequestMapping（valuethenCombine）publicvoidthenCombine（）｛CompletableFutureStringfuture1CompletableFuture。supplyAsync（（）｛System。out。println（执行future1开始。。。）；returnHello；｝，asyncThreadPoolExecutor）；CompletableFutureStringfuture2CompletableFuture。supplyAsync（（）｛System。out。println（执行future2开始。。。）；returnWorld；｝，asyncThreadPoolExecutor）；future1。thenCombine（future2，（result1，result2）｛Stringresultresult1result2；System。out。println（获取到future1、future2聚合结果：result）；returnresult；｝）。thenAccept（resultSystem。out。println（result））；｝
　　接口访问，打印结果：threadname：customAsyncTaskExecutor4执行future1开始。。。threadname：customAsyncTaskExecutor5执行future2开始。。。threadname：httpnio10032exec8获取到future1、future2聚合结果：HelloWorldHelloWorld复制代码5thenCompose（）
　　我们先有future1，然后和future2组成一个链：future1future2，然后又组合了future3，形成链：future1future2future3。这里有个隐藏的点：future1、future2、future3它们完全没有数据依赖关系，我们只不过是聚合了它们的结果。RequestMapping（valuethenCompose）publicvoidthenCompose（）｛CompletableFuture。supplyAsync（（）｛第一个Future实例结果System。out。println（threadname：Thread。currentThread（）。getName（）执行future1开始。。。）；returnHello；｝，customAsyncTaskExecutor）。thenCompose（result1CompletableFuture。supplyAsync（（）｛将上一个Future实例结果传到这里System。out。println（threadname：Thread。currentThread（）。getName（）执行future2开始。。。，第一个实例结果：result1）；returnresult1World；｝））。thenCompose（result12CompletableFuture。supplyAsync（（）｛将第一个和第二个实例结果传到这里System。out。println（threadname：Thread。currentThread（）。getName（）执行future3开始。。。，第一第二个实现聚合结果：result12）；StringtargetResultresult12，Iamaustin！；System。out。println（最终输出结果：targetResult）；returntargetResult；｝））；｝
　　接口访问，打印结果：threadname：customAsyncTaskExecutor1执行future1开始。。。threadname：ForkJoinPool。commonPoolworker3执行future2开始。。。，第一个实例结果：Hellothreadname：ForkJoinPool。commonPoolworker3执行future3开始。。。，第一第二个实现聚合结果：HelloWorld最终输出结果：HelloWorld，Iamaustin！Note：thenCombine（）VSthenCompose（），两者之间的区别
　　thenCombine结合的两个CompletableFuture没有依赖关系，且第二个CompletableFuture不需要等第一个CompletableFuture执行完成才开始。thenCompose（）可以两个CompletableFuture对象，并将前一个任务的返回结果作为下一个任务的参数，它们之间存在着先后顺序。thenCombine（）会在两个任务都执行完成后，把两个任务的结果合并。两个任务是并行执行的，它们之间并没有先后依赖顺序。4。2《CompletableFuture实例化创建》返回一个新的CompletableFuture，由线程池ForkJoinPool。commonPool（）中运行的任务异步完成，不会返回结果。publicstaticCompletableFutureVoidrunAsync（Runnablerunnable）；返回一个新的CompletableFuture，运行任务时可以指定自定义线程池来实现异步，不会返回结果。publicstaticCompletableFutureVoidrunAsync（Runnablerunnable，Executorexecutor）；返回由线程池ForkJoinPool。commonPool（）中运行的任务异步完成的新CompletableFuture，可以返回异步线程执行之后的结果。publicstaticUCompletableFutureUsupplyAsync（SupplierUsupplier）；publicstaticUCompletableFutureUsupplyAsync（SupplierUsupplier，Executorexecutor）；
　　CompletableFuture有两种方式实现异步，一种是supply开头的方法，一种是run开头的方法：supply开头：该方法可以返回异步线程执行之后的结果；run开头：该方法不会返回结果，就只是执行线程任务。4。3《获取CompletableFuture结果》publicTget（）publicTget（longtimeout，TimeUnitunit）publicTgetNow（TvalueIfAbsent）publicTjoin（）publicCompletableFutureObjectallOf（）publicCompletableFutureObjectanyOf（）
　　使用方式，演示：CompletableFutureIntegerfuturenewCompletableFuture（）；Integerintegerfuture。get（）；get（）：阻塞式获取执行结果，如果任务还没有完成则会阻塞等待知直到任务执行完成get（longtimeout，TimeUnitunit）：带超时的阻塞式获取执行结果getNow（）：如果已完成，立刻返回执行结果，否则返回给定的valueIfAbsentjoin（）：该方法和get（）方法作用一样，不抛异常的阻塞式获取异步执行结果allOf（）：当给定的所有CompletableFuture都完成时，返回一个新的CompletableFutureanyOf（）：当给定的其中一个CompletableFuture完成时，返回一个新的CompletableFutureNote：
　　join（）和get（）方法都是阻塞式调用它们的线程（通常为主线程）来获取CompletableFuture异步之后的返回值。两者的区别在于join（）返回计算的结果或者抛出一个unchecked异常CompletionException，而get（）返回一个具体的异常。4。4《结果处理》
　　当使用CompletableFuture异步调用计算结果完成、或者是抛出异常的时候，我们可以执行特定的Action做进一步处理，比如：publicCompletableFutureTwhenComplete（BiConsumerlt；？superT，？superThrowableaction）publicCompletableFutureTwhenCompleteAsync（BiConsumerlt；？superT，？superThrowableaction）publicCompletableFutureTwhenCompleteAsync（BiConsumerlt；？superT，？superThrowableaction，Executorexecutor）4。5《异常处理》
　　使用CompletableFuture编写代码时，异常处理很重要，CompletableFuture提供了三种方法来处理它们：handle（）、whenComplete（）和exceptionly（）。handle：返回一个新的CompletionStage，当该阶段正常或异常完成时，将使用此阶段的结果和异常作为所提供函数的参数执行，不会将内部异常抛出。whenComplete：返回与此阶段具有相同结果或异常的新CompletionStage，该阶段在此阶段完成时执行给定操作。与方法handle不同，会将内部异常往外抛出。exceptionally：返回一个新的CompletableFuture，CompletableFuture提供了异常捕获回调exceptionally，相当于同步调用中的trycatch。AutowiredprivateRemoteDictServiceremoteDictService；publicCompletableFutureDictgetDictDataAsync（longdictId）｛CompletableFutureDictResultresultFutureremoteDictService。findDictById（dictId）；业务方法，内部会发起异步rpc调用returnresultFuture。exceptionally（error｛通过exceptionally捕获异常，打印日志并返回默认值log。error（RemoteDictService。getDictDataAsyncExceptiondictId｛｝，dictId，error）；returnnull；｝）；｝handle（）VSwhenComplete（），两者之间的区别核心区别在于whenComplete不消费异常，而handle消费异常Twomethodformssupportprocessingwhetherthetriggeringstagecompletednormallyorexceptionally：
　　Method｛whenComplete｝allowsinjectionofanactionregardlessofoutcome，otherwisepreservingtheoutcomeinitscompletion。
　　Method｛handle｝additionallyallowsthestagetocomputeareplacementresultthatmayenablefurtherprocessingbyotherdependentstages。
　　翻译过来就是：
　　两种方法形式支持处理触发阶段是否正常完成或异常完成：whenComplete：可以访问当前CompletableFuture的结果和异常作为参数，使用它们并执行您想要的操作。此方法并不能转换完成的结果，会内部抛出异常。handle：当此阶段正常或异常完成时，将使用此阶段的结果和异常作为所提供函数的参数来执行。当此阶段完成时，以该阶段的结果和该阶段的异常作为参数调用给定函数，并且函数的结果用于完成返回的阶段，不会把异常外抛出来。
　　这里我通过代码演示一下：publicclassCompletableFutureExceptionHandler｛publicstaticCompletableFuturehandle（inta，intb）｛returnCompletableFuture。supplyAsync（（）ab）。handle（（result，ex）｛if（null！ex）｛System。out。println（handleerror：ex。getMessage（））；return0；｝else｛returnresult；｝｝）；｝publicstaticCompletableFuturewhenComplete（inta，intb）｛returnCompletableFuture。supplyAsync（（）ab）。whenComplete（（result，ex）｛if（null！ex）｛System。out。println（whenCompleteerror：ex。getMessage（））；｝｝）；｝publicstaticvoidmain（String〔〕args）｛try｛System。out。println（success：handle（10，5）。get（））；System。out。println（fail：handle（10，0）。get（））；｝catch（Exceptione）｛System。out。println（catchexceptione。getMessage（））；｝System。out。println（）；try｛System。out。println（success：whenComplete（10，5）。get（））；System。out。println（fail：whenComplete（10，0）。get（））；｝catch（Exceptione）｛System。out。println（catchexceptione。getMessage（））；｝｝｝
　　运行结果如下显示：success：2handleerror：java。lang。ArithmeticException：byzerofail：0success：2whenCompleteerror：java。lang。ArithmeticException：byzerocatchexceptionjava。lang。ArithmeticException：byzero
　　可以看到，handle处理，当程序发生异常的时候，即便是catch获取异常期望输出，但是并未跟实际预想那样，原因是handle不会把内部异常外抛出来，而whenComplete会将内部异常抛出。五、CompletableFuture线程池须知Note：关于异步线程池（十分重要）
　　异步回调方法可以选择是否传递线程池参数Executor，这里为了实现线程池隔离，当不传递线程池时，默认会使用ForkJoinPool中的公共线程池CommonPool，这个线程池默认创建的线程数是CPU的核数，如果所有的异步回调共享一个线程池，核心与非核心业务都竞争同一个池中的线程，那么一旦有任务执行一些很慢的IO操作，就会导致线程池中所有线程都阻塞在IO操作上，很容易成为系统瓶颈，影响整个系统的性能。因此，建议强制传线程池，且根据实际情况做线程池隔离，减少不同业务之间的相互干扰。六、基于CompletableFuture实现接口异步revoke案例实现Controller层RestControllerRequestMapping（index）publicclassIndexWebController｛ResourceprivateThreadPoolExecutorasyncThreadPoolExecutor；RequestMapping（valuehomeIndex，method｛RequestMethod。POST，RequestMethod。GET｝）publicStringhomeIndex（RequestParam（requiredfalse）StringuserId，RequestParam（valuelang）Stringlang）｛ResultDataHomeVOresultnewResultData（）；获取Banner轮播图信息CompletableFutureListBannerVOfuture1CompletableFuture。supplyAsync（（）this。buildBanners（userId，lang），asyncThreadPoolExecutor）；获取用户message通知信息CompletableFutureNotificationVOfuture2CompletableFuture。supplyAsync（（）this。buildNotifications（userId，lang），asyncThreadPoolExecutor）；获取用户权益信息CompletableFutureListBenefitVOfuture3CompletableFuture。supplyAsync（（）this。buildBenefits（userId，lang），asyncThreadPoolExecutor）；获取优惠券信息CompletableFutureListCouponVOfuture4CompletableFuture。supplyAsync（（）this。buildCoupons（userId），asyncThreadPoolExecutor）；CompletableFutureVoidallOfFutureCompletableFuture。allOf（futrue1，futrue2，futrue3，future4）；HomeVofinalHomeVOhomeVO；CompletableFutureHomeVOresultFutureallOfFuture。thenApply（v｛try｛finalHomeVo。setBanners（future1。get（））；finalHomeVo。setNotifications（future2。get（））；finalHomeVo。setBenefits（future3。get（））；finalHomeVo。setCoupons（future4。get（））；returnfinalHomeVO；｝catch（Exceptione）｛logger。error（〔Error〕assemblehomeVOdataerror：｛｝，e）；thrownewRuntimeException（e）；｝｝）；homeVOresultFuture。join（）；result。setData（homeVO）；returnwriteJson（result）；｝｝Service层SneakyThrowspublicListBannerVObuildBanners（StringuserId，Stringlang）｛模拟请求耗时0。5秒Thread。sleep（500）；returnnewListBannerVO（）；｝SneakyThrowspublicListNotificationVObuildNotifications（StringuserId，Stringlang）｛模拟请求耗时0。5秒Thread。sleep（500）；returnnewListNotificationVO（）；｝SneakyThrowspublicListBenefitVObuildBenefits（StringuserId，Stringlang）｛模拟请求耗时0。5秒Thread。sleep（500）；returnnewListBenefitVO（）；｝SneakyThrowspublicListCouponVObuildCoupons（StringuserId）｛模拟请求耗时0。5秒Thread。sleep（500）；returnnewListCouponVO（）；｝六、异步化带来的性能提升通过异步化改造，原本同步获取数据的API性能得到明显提升，大大减少了接口的响应时长（RT）。接口的吞吐量大幅度提升。七、总结
　　本篇文章主要是介绍了CompletableFuture使用原理和相关不同方法的场景化使用，以及通过不同的实例演示了异步回调的过程，好了，今天的分享就到此结束了，如果文章对你有所帮助，欢迎点赞评论收藏，