新手问个问题，为什么我写的async函数会报错

解决函数回调经历了几个阶段， Promise 对象， Generator 函数到async函数。async函数目前是解决函数回调的最佳方案。很多语言目前都实现了async，包括Python ，java spring，go等。 async 函数返回一个 Promise 对象，当函数执行的时候，一旦遇到 await 就会先返回，等到触发的异步操作完成，再接着执行函数体内后面的语句。 async /await 需要在function外部书写async，在内部需要等待执行的函数前书写await即可 理解async函数需要先理解Generator函数，因为async函数是Generator函数的语法糖。 Generator是ES6标准引入的新的数据类型。Generator可以理解为一个状态机，内部封装了很多状态，同时返回一个迭代器Iterator对象。可以通过这个迭代器遍历相关的值及状态。 Generator的显著特点是可以多次返回，每次的返回值作为迭代器的一部分保存下来，可以被我们显式调用。 一般的函数使用function声明，return作为回调(没有遇到return，在结尾调用return undefined)，只可以回调一次。而Generator函数使用function*定义，除了return，还使用yield返回多次。 在chrome浏览器中这个例子里，我们可以看到，在执行foo函数后返回了一个 Generator函数的实例。它具有状态值suspended和closed，suspended代表暂停，closed则为结束。但是这个状态是无法捕获的，我们只能通过Generator函数的提供的方法获取当前的状态。 在执行next方法后，顺序执行了yield的返回值。返回值有value和done两个状态。value为返回值，可以是任意类型。done的状态为false和true，true即为执行完毕。在执行完毕后再次调用返回{value: undefined, done: true} 注意:在遇到return的时候，所有剩下的yield不再执行，直接返回{ value: undefined, done: true } Generator函数提供了3个方法，next/return/throw next方式是按步执行，每次返回一个值,同时也可以每次传入新的值作为计算 return则直接跳过所有步骤，直接返回 {value: undefined, done: true} throw则根据函数中书写try catch返回catch中的内容，如果没有写try，则直接抛出异常 这里可以看到在执行throw之前，顺序的执行了状态，但是在遇到throw的时候，则直接走进catche并改变了状态。 这里还要注意一下，因为状态机是根据执行状态的步骤而执行，所以如果执行thow的时候，没有遇到try catch则会直接抛错 以下面两个为例 这个例子与之前的执行状态一样，因为在执行到throw的时候，已经执行到try语句，所以可以执行，而下面的例子则不一样 执行throw的时候，还没有进入到try语句，所以直接抛错，抛出undefined为throw未传参数，如果传入参数则显示为传入的参数。此状态与未写try的抛错状态一致。 遍历 Generator函数的返回值是一个带有状态的Generator实例。它可以被for of 调用，进行遍历，且只可被for of 调用。此时将返回他的所有状态 调用for of方法后，在后台调用next(),当done属性为true的时候，循环退出。因此Generator函数的实例将顺序执行一遍，再次调用时，状态为已完成 状态的存储和改变 Generator函数中yield返回的值是可以被变量存储和改变的。 以上的执行结果中，我们可以看到，在第二步的时候，我们传入2这个参数，foo函数中的a的变量的值0被替换为2，并且在第4次迭代的时候，返回的是2。而第三次迭代的时候，传入的3参数，替换了b的值4，并在第5次迭代的时候返回了3。所以传入的参数，是替代上一次迭代的生成值。 yield 委托* 在Generator函数中，我们有时需要将多个迭代器的值合在一起，我们可以使用yield *的形式，将执行委托给另外一个Generator函数 foo在执行的时候，首先委托给了foo1，等foo1执行完毕，再委托给foo2。但是我们发现，”foo1 end” 这一句并没有输出。 在整个Generator中，return只能有一次，在委托的时候，所有的yield*都是以函数表达式的形式出现。return的值是表达式的结果，在委托结束之前其内部都是暂停的，等待到表达式的结果的时候，将结果直接返回给foo。此时foo内部没有接收的变量，所以未打印。 如果我们希望捕获这个值，可以使用yield *foo()的方式进行获取。 如上，我们掌握了Generator函数的使用方法。async/await语法糖就是使用Generator函数+自动执行器来运作的。 我们可以参考以下例子 在执行的过程中，判断一个函数的promise是否完成，如果已经完成，将结果传入下一个函数，继续重复此步骤。 async/await非常好理解，基本理解了Generator函数之后，几句话就可以描述清楚。这里没有过多的继续阐述Generator函数的内部执行逻辑及原理，如果有对此有深入理解的童鞋，欢迎补充说明。

是分析的意思，分析函数

1、消息队列MQ 2、线程池处理。 我们来看看Spring框架中如何去使用线程池来完成异步操作，以及分析背后的原理。 在Spring4中，Spring中引入了一个新的注解@Async，这个注解让我们在使用Spring完成异步操作变得非常方便。 Spring异步线程池的接口类，其实质是java.util.concurrent.Executor Spring 已经实现的异常线程池： Spring中用@Async注解标记的方法，称为异步方法。在spring boot应用中使用@Async很简单： 1、调用异步方法类上或者启动类加上注解@EnableAsync 2、在需要被异步调用的方法外加上@Async 3、所使用的@Async注解方法的类对象应该是Spring容器管理的bean对象； 启动类加上注解@EnableAsync： 在需要被异步调用的方法外加上@Async，同时类AsyncService加上注解@Service或者@Component，使其对象成为Spring容器管理的bean对象； 这里需要注意的是： 1、同一个类里面调用异步方法不生效：原因默认类内的方法调用不会被aop拦截，即调用方和被调用方是在同一个类中，是无法产生切面的，该对象没有被Spring容器管理。即@Async方法不生效。 解决办法：如果要使同一个类中的方法之间调用也被拦截，需要使用spring容器中的实例对象，而不是使用默认的this，因为通过bean实例的调用才会被spring的aop拦截 本例使用方法：AsyncService asyncService = context.getBean(AsyncService.class); 然后使用这个引用调用本地的方法即可达到被拦截的目的 备注：这种方法只能拦截protected，default，public方法，private方法无法拦截。这个是spring aop的一个机制。 2、如果不自定义异步方法的线程池默认使用SimpleAsyncTaskExecutor。SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。并发大的时候会产生严重的性能问题。 3、异步方法返回类型只能有两种：void和java.util.concurrent.Future。 1）当返回类型为void的时候，方法调用过程产生的异常不会抛到调用者层面， 可以通过注AsyncUncaughtExceptionHandler来捕获此类异常 2）当返回类型为Future的时候，方法调用过程产生的异常会抛到调用者层面 在Spring Boot主类中定义一个线程池，public Executor taskExecutor() 方法用于自定义自己的线程池，线程池前缀”taskExecutor-”。如果不定义，则使用系统默认的线程池。 上面我们通过ThreadPoolTaskExecutor创建了一个线程池，同时设置了如下参数： 核心线程数10：线程池创建时初始化的线程数 最大线程数20：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程 缓冲队列200：用来缓冲执行任务的队列 允许线程的空闲时间60秒：超过了核心线程数之外的线程，在空闲时间到达之后会被销毁 线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池 线程池对拒绝任务的处理策略：此处采用了CallerRunsPolicy策略，当线程池没有处理能力的时候，该策略会直接在execute方法的调用线程中运行被拒绝的任务；如果执行程序已被关闭，则会丢弃该任务 设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean 设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住 也可以单独类来配置线程池： 只需要在@Async注解中指定线程池名即可 Bean文件配置: spring_async.xml 1. 线程的前缀为xmlExecutor 2. 启动异步线程池配置 启动类导入xml文件： 线 程池参数说明 1. ‘id" ： 线程名称的前缀 2. ‘pool-size"：线程池的大小。支持范围”min-max”和固定值（此时线程池core和max sizes相同） 3. ‘queue-capacity" ：排队队列长度 4. ‘rejection-policy": 对方拒绝的任务处理策略 5. ‘keep-alive" ： 线程保护时间（单位秒） 上面也提到：在调用方法时，可能出现方法中抛出异常的情况。在异步中主要有有两种异常处理方法： a) 、一种是在调用future的get时捕获异常; b)、 在异常方法中直接捕获异常 实现AsyncConfigurer接口对异常线程池更加细粒度的控制 a) 创建线程自己的线程池 b) 对void方法抛出的异常处理的类AsyncUncaughtExceptionHandler 上面也提到：如果不自定义异步方法的线程池默认使用SimpleAsyncTaskExecutor。SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。并发大的时候会产生严重的性能问题。 一般的错误OOM：OutOfMemoryError：unable to create new native thread，创建线程数量太多，占用内存过大. 解决办法：一般最好使用自定义线程池，做一些特殊策略, 比如自定义拒绝策略，如果队列满了，则拒绝处理该任务。 原文链接：https://blog.csdn.net/hguisu/article/details/106671893

是的。async研究所是专门研究高难度医学和医学上的疑难杂症而开设的，都是由专业的医学研究着组成的。是存在于现实的。async中医药研究所拥有一支治学严谨的高精尖队伍，async研究所有知名的中医专家、学者、研究人员和临床高、中级医师100余人，四川华西中医药研究所更有国外顶尖专家团队推动助力国医发。

前面比较啰嗦，希望读者耐心看完。 async/await可以说是一个老生常谈，但是每一个前端工程师却又避不开的话题。 在JQuery一把梭的时代，如果遇到下面类似的需求，你要怎么做？ 需求：拿到第一个ajax请求省，拿到省数据请求第二个ajax来获得市的数据，拿到市的数据再请求第三个ajax来获得区的数据。 最常见的写法莫过于两种： 1、回调地狱式写法： 简直令人发疯。 或者是这样？同步请求 我靠，只要一个数据请求不回来页面就完犊子了。这简直是噩梦。 别笑，我相信身为前端工程师一定这么写过。 直到有一天，你发现vue里没有Jquery，只有基于promise写的axios. 一开始在使用axios的时候，还是脱离不了必须同步请求的变成思想，于是在vue项目中引入了jquery，把项目搞成了四不像。 研究了好久，终于发现了async/await async 词面翻译 “异步”。 async关键字一般放到function的前面，用来表示一个异步函数。如下 根据阮一峰es6教程关于async部分的介绍，能得知async会返回一个Promise对象。所以我们可以通过then来调用。 如果不太明白，那我这么写你一定会明白： 词面意思“等待”，它只会在async函数体内出现，代表执行到这里的时候，等一下。它后面可以跟任何表达式，不过一般会跟一个Promise，可以实现异步函数同步调用的效果。 delay是异步函数，在正常情况下，如果这样写： 会先输出2，然后1秒后再输出1. 但是在await的影响下，函数会先等待5秒后输出a，在等待4秒后输出b。 话题再转回到我们一开始说的ajax，使用async/await的方法来写，是不是感觉优雅多了？ 在vue中，我们会使用axios来与后台做数据交互，axios没有同步请求，只有异步请求，所以我们可以使用async/await来模拟一个同步请求，实现功能。

众所周知C#提供Async和Await关键字来实现异步编程。在本文中，我们将共同探讨并介绍什么是Async 和 Await，以及如何在C#中使用Async 和 Await。 同样本文的内容也大多是翻译的，只不过加上了自己的理解进行了相关知识点的补充，如果你认为自己的英文水平还不错，大可直接跳转到文章末尾查看原文链接进行阅读。 自从C# 5.0时代引入async和await关键字后，异步编程就变得流行起来。尤其在现在的.NET Core时代，如果你的代码中没有出现async或者await关键字，都会让人感觉到很奇怪。 想象一下当我们在处理UI和按钮单击时，我们需要运行一个长时间运行的方法，比如读取一个大文件或其他需要很长时间的任务，在这种情况下，整个应用程序必须等待这个长时间运行的任务完成才算完成整个任务。 换句话说，如果同步应用程序中的任何进程被阻塞，则整个应用程序将被阻塞，我们的应用程序将停止响应，直到整个任务完成。 在这种情况下，异步编程将非常有用。通过使用异步编程，应用程序可以继续进行不依赖于整个任务完成的其他工作。 在Async 和 await关键字的帮助下，使得异步编程变得很简单，而且我们将获得传统异步编程的所有好处。 假设我们分别使用了两种方法，即Method 1和Method 2，这两种方法不相互依赖，而Method 1需要很长时间才能完成它的任务。在同步编程中，它将执行第一个Method 1，并等待该方法的完成，然后执行Method 2。因此，这将是一个时间密集型的过程，即使这两种方法并不相互依赖。 我们可以使用简单的多线程编程并行运行所有方法，但是它会阻塞UI并等待完成所有任务。要解决这个问题，我们必须在传统编程中编写很多的代码，但是现在我们有了Async 和 await关键字，那么我们将通过书写很少的并且简洁的代码来解决这个问题。 此外，我们还将看到更多的示例，如果任何第三个方法(如Method 3)都依赖于Method 1，那么它将在Wait关键字的帮助下等待Method 1的完成。 Async 和 await是代码标记，它标记代码位置为任务完成后控件应该恢复的位置。 下面让我们举几个例子来更好进行理解吧 C#中Async 和 await关键字的示例 我们将采用控制台应用程序进行演示。 在这个例子中，我们将采取两个不相互依赖的方法。 在上面给出的代码中，Method 1和Method 2不相互依赖，我们是从主方法调用的。 在这里，我们可以清楚地看到，方法1和方法2并不是在等待对方完成。 输出 现在来看第二个例子，假设我们有Method 3，它依赖于Method 1 在本例中，Method 1将总长度作为整数值返回，我们在Method 3中以长度的形式传递一个参数，它来自Method 1。 在这里，在传递Method 3中的参数之前，我们必须使用AWAIT关键字，为此，我们必须使用调用方法中的async 关键字。 在控制台应用程序的Main方法中，因为不能使用async关键字而不能使用await 关键字，因为它会给出下面给出的错误。(但是如果你使用的是C#7.1及以上的方法是不会有问题的，因为C#7.1及以上的语法支持Mian方法前加async) 我们将创建一个新的方法，作为CallMethod，在这个方法中，我们将调用我们的所有方法，分别为Method 1、Method 2和Method 3。 在上面给出的代码中，Method 3需要一个参数，即Method 1的返回类型。在这里，await关键字对于等待Method 1任务的完成起着至关重要的作用。 输出 .NET Framework4.5中有一些支持API，Windows运行时包含支持异步编程的方法。 在Async 和 await关键字的帮助下，我们可以在实时项目中使用所有这些，以便更快地执行任务。 包含异步方法的API有HttpClient, SyndicationClient, StorageFile, StreamWriter, StreamReader, XmlReader, MediaCapture, BitmapEncoder, BitmapDecoder 等。 在本例中，我们将异步读取大型文本文件中的所有字符，并获取所有字符的总长度。 在上面给出的代码中，我们调用ReadFile方法来读取文本文件的内容，并获取文本文件中总字符的长度。 在sampleText.txt中，文件包含了太多的字符，因此读取所有字符需要很长时间。 在这里，我们使用异步编程从文件中读取所有内容，所以它不会等待从这个方法获得一个返回值并执行其他代码行，但是它必须等待下面给出的代码行，因为我们使用的是等待关键字，我们将对下面给出的代码行使用返回值。 随后，将按顺序执行其他代码行。 输出 在这里，我们必须了解非常重要的一点，如果我们没有使用await 关键字，那么该方法就作为一个同步方法。编译器将向我们显示警告，但不会显示任何错误。 像上面这种简单的方式一样，我们可以在C#代码中使用async 和await关键字来愉快的进行异步编程了。 最后的最后感谢大家的阅读！

generator函数的语法糖。 Async 函数返回一个 Promise 对象，当函数执行的时候，遇到 await 就会先返回，等到异步处理完成之后，再接着处理函数体内await后面的语句。 eg.1 上面这个async函数大概效果就是，请求"categorySearch‘接口，获取返回结果，并把获取到的data值赋值给"searchResult‘。 分析为什么要这么写 ？ service应该改是个异步接口请求的方法，请求需要一定时间；我们必须等接口请求成功有返回值时，才能给searchResult赋值；否则searchResult赋值结果可能是空。 eg.2 这个async函数例子和上面的例子最大的区别就是加了then()方法处理。 为什么可以使用then？ async函数返回的是一个Promise对象，所以可以使用then方法处理。而且， async函数内部return语句的返回值，会成为then方法回电函数的参数 。 同样，async函数也可以使用catch方法处理错误。 有上面的两个简单的例子可以看出来主要有下面两个。 以上总结主要来自于 阮一峰的ES6入门教程之async一章

1、defer 和 async 在网络读取（脚本下载）这块儿是一样的，都是异步的（相较于 HTML 解析）2、两者的差别：在于脚本下载完之后何时执行，显然 defer 是最接近我们对于应用脚本加载和执行的要求的。defer是立即下载但延迟执行，加载后续文档元素的过程将和脚本的加载并行进行（异步），但是脚本的执行要在所有元素解析完成之后，DOMContentLoaded 事件触发之前完成。async是立即下载并执行，加载和渲染后续文档元素的过程将和js脚本的加载与执行并行进行（异步）。3、关于 defer，我们还要记住的是它是按照加载顺序执行脚本的4、标记为async的脚本并不保证按照指定它们的先后顺序执行。对它来说脚本的加载和执行是紧紧挨着的，所以不管你声明的顺序如何，只要它加载完了就会立刻执行。5、async 对于应用脚本的用处不大，因为它完全不考虑依赖（哪怕是最低级的顺序执行），不过它对于那些可以不依赖任何脚本或不被任何脚本依赖的脚本来说却是非常合适的。

首先一个被标记为async的方法，可以没有await调用，只不过会有编译警告。这是很显然的，不是说你把一个方法标记成async这个方法就成了异步调用的方法了。async这个关键词其实反而是可以省略的，这个关键词存在的意义是为了向下兼容，为await提供上下文而已。所以，一个async的方法里面没有await的调用，那等于是脱了裤子放屁，本质上只是把return xxx改成了retrurn Task.FromResult( xxx )而已，没有任何变化。如果一个方法加上了async他就自动成为了异步的调用，说明你连最根本的异步是什么都没搞清楚。你所理解的那种所谓的异步，直接用Task.Run就可以了。

promise和async await区别是：1、简洁干净使用async/await能省去写多少行代码。2、错误处理async/wait能用相同的结构和好用的经典try/catch处理同步和异步错误，错误堆栈能指出包含错误的函数。3、调试async/await的一个极大优势是它更容易调试，使用async/await则无需过多箭头函数，并且能像正常的同步调用一样直接跨过await调用。Async await进一步优化了Promise的缺点，使代码更简洁。函数前使用关键字async，await只能用在async标记的函数内。比promise更简洁处理结果上：promise需要使用．then()来处理promise返回的结果，而async/await则直接在代码上顺序处理结果。promise的诞生是为了简化函数嵌套调用流程，也便于后续维护。async/await定义了异步函数，并在其内部可通过await等待promise对象，阻塞后续的执行。

基本使用方式： 方法后面跟上 async 表示是一个异步函数。如果调用异步函数 在正常返回的函数中使用 async 修饰的func时，需要用Task{} 进行包装，否则报错 使用方式： 属性也可以 async properties 使用异步属性，必须只能是 get 属性。可写属性不能使用异步属性。 public func resume(returning x: T) 接收 completion 中的数据返回，转换成 async 函数返回。 public func resume(throwing x: E) 进行抛出异常 withCheckedContinuation 方法中的 checked 会在运行时对操作进行检查：是否调用 resume 进行返回。如果不调用会造成资源泄露。多次调用也会造成问题。 continuation 有且只能 resume 一次。 withUnsafeContinuation 的工作机制和 withCheckedContinuation 一致，唯一区别在于运行时不会对操作进行检查。但性能更好。实际使用中 withCheckedContinuation 测试没有问题后，正式发布时使用 withUnsafeContinuation 使用方式如下： withCheckedContinuation 如果有抛出异常 withCheckedThrowingContinuation

async 是用来修饰函数的声明, 使用async 修饰的函数会变成一个异步函数. await 用来修饰函数的调用, 被 await 修饰的函数必须返回一个promise 异步对象, 使用 await 修饰后, 就会将 promise 异步对象转换成一个同步操作.

function async () {}setTimeout(function(){ async();}, 1000) 上面就是异步调用一个函数。 js里的异步函数有很多， 除了setTimeout和setInterval 还有bind以及很多事件绑定和监听都属于异步操作。

是的。async研究所是专门研究高难度医学和医学上的疑难杂症而开设的，都是由专业的医学研究者组成的。是存在于现实的。

settimeout是异步方法，会排到消息队列去执行，也就是执行异步方法的队列称为消息队列。 js主要是多线程执行的，而执行非异步方法的部分称为主线程，消息队列其实也是一个线程，称为副线程，而主线程执行完毕才会执行副线程。 副线程（消息队列）并非只有一个，为了执行效率和顺序分为 宏任务线程 与 微任务线程 ，只有微任务进程执行完才会执行宏任务进程 其中23456就是事件轮询 Generator函数是协程在 ES6 的实现，最大特点就是可以交出函数的执行权 该函数返回一个状态机，必须要靠状态机.next()才能执行 执行过程只需要记住一句话 执行到yield就暂停，返回yield后面值，第一次执行参数无用，再次执行参数赋给yield前面的表达式。 async、await是Generator函数的语法糖，原理是通过Generator函数加自动执行器来实现的，这就使得async、await跟普通函数一样了，不用再一直next执行了 所以本质上async await是generator与promise结合的语法糖 三者调用请求的对比案例： promise generator async

是异步；异步与多线程，从辩证关系上来看，异步和多线程并不时一个同等关系；异步是目的，多线程只是我们实现异步的一个手段。什么是异步？异步是当一个调用请求发送给被调用者，而调用者不用等待其结果的返回。实现异步可以采用多线程技术或则交给另外的进程来处理。

fsync要AMD显卡支持。Async Compute是Pascal架构新卡GTX 1080做了很多努力工作减小Maxwell时代在DX12异步运算。

恩 vs2010后就代替了

如果async="async"就是一部加载，异步加载的意思就是js相对于html异步的执行，也就是页面继续进行解析时，js将会被执行。换句话说就是js和html的执行顺序不会有绝对的先后顺序。

async异步，默认值为true。异步就是不必等Ajax请求完成，就可以先执行后面的代码了。为false时，就是一定要Ajax请求完成，再往后执行后面的代码。

　　这个await，其实只是把对老版本C#迭代器的惯用法官方化了。现在很多平台都因为一些原因不得不用旧版本的C#，比如unity，想异步那只能通过迭代器来做。　　async、迭代器都是语法糖，编译器会帮你实现成一个状态机匿名类，实例里面hold住一些临时变量，记录一下当前状态。根据你写的yield/await，把一个异步方法拆成几个同步block，根据一定规则定期的去MoveNext一下，Current是Task那我就根据你配置的线程上下文决定把这个Task跑在哪个线程上。　　那么用await修饰的异步方法是在哪个线程中被调用的？为什么上面这个事件处理方法不会阻塞GUI？　　我还看到其它一些描述是说使用async/await异步模式不会生成新的线程，那么只在原来已有线程的基础上面如何做到异步运行？　　题主这个例子这个方法就是在UI线程调用的，并且没有ConfigureAwait(false)，所以会在当前await时捕捉的UI线程上下文执行之后的同步block。　　至于为什么不会阻塞，可以简单理解为执行了第一个block，碰到Delay(4000)，给UI线程的定时器挂一个4000时间之后再调用下一个同步块的回调。　　看题主说的书名像是国产的书，这方面还是看《CLR via C#》或者《Concurrency in C# cookbook》比较好。

kotlin之协程(一),线程,进程,协程,协程可以替换线程吗? kotlin之协程(二),Kotlin协程是什么、挂起是什么、挂起的非阻塞式 kotlin之协程(三),开始创建协程,launch,withContext kotlin之协程(四),协程的核心关键字suspend kotlin之协程(五),launch 函数以及协程的取消与超时 kotlin之协程(七),协程中relay、yield 区别 launch 函数定义： async 函数定义： 从源码可以看出launch 和 async的唯一区别在于async的返回值 async 返回的是 Deferred 类型，Deferred 继承自 Job 接口，Job有的它都有，增加了一个方法 await ，这个方法接收的是 async 闭包中返回的值，async 的特点是不会阻塞当前线程，但会阻塞所在协程，也就是挂起 runBlocking 启动的协程任务会阻断当前线程，直到该协程执行结束。当协程执行结束之后，页面才会被显示出来。 runBlocking 通常适用于单元测试的场景，而业务开发中不会用到这个函数

点的

1、对于耗时的操作，我们的一般方法是开启“子线程”。如果需要更新UI，则需要使用handler。2、如果耗时的操作太多，那么我们需要开启太多的子线程，这就会给系统带来巨大的负担，随之也会带来性能方面的问题。在这种情况下我们就可以考虑使用类AsyncTask来异步执行任务，不需要子线程和handler，就可以完成异步操作和刷新UI。3、AsyncTask：对线程间的通讯做了包装，是后台线程和UI线程可以简易通讯：后台线程执行异步任务，将result告知UI线程。使用方法：共分为两步，自定义AsyncTask，在耗时的地方调用自定义的AsyncTask。可以参照以下代码示例。step1：继承AsyncTaskParams:输入参数。对应的是调用自定义的AsyncTask的类中调用excute()方法中传递的参数。如果不需要传递参数，则直接设为Void即可。Progress：子线程执行的百分比。Result：返回值类型。和doInBackground（）方法的返回值类型保持一致。step2：实现以下几个方法：执行时机和作用看示例代码，以下对返回值类型和参数进行说明。onPreExecute()：无返回值类型。doInBackground(Params... params)：返回值类型和Result保持一致。参数：若无就传递Void；若有，就可用Params。 publishProgress(Params... params)：在执行此方法的时候会直接调用onProgressUpdate(Params... values)。onProgressUpdate(Params... values)：无返回值类型。参数：若无就传递Void；若有，就可用Progress。onPostExecute(Result result) ：无返回值类型。参数：和Result保持一致。step3：在调用自定义的AsyncTask类中生成对象。

大家都知道 用@Trancational，@Async，@Retryable 等注解时，需要用代理调用才生效，用this调用是不生效的。 大多数情况，是由另外的类发起调用，这是没有问题的。 少数情况下，存在本类调用本类方法，这种情况下要做到注解生效，该怎么办呢？ 常见的解决方法有以下几种： @EnableAsync注解上标注了@Import(AsyncConfigurationSelector.class)，AsyncConfigurationSelector在默认情况下，会选择出来ProxyAsyncConfiguration类进行导入，即把ProxyAsyncConfiguration类作为@Configuration类配置到ApplicationContext 这段代码的作用是把AsyncAnnotationBeanPostProcessor作为Bean注册到Context中。 我们看下这个Async相关的BPP做了什么操作： Spring在对一个类进行AOP代理后，会为此类加上Advised接口，返回的动态代理对象都会带上Advised接口修饰，那么第一段逻辑判断bean instanceof Advised的目的就是判断是否已经是被动态代理的类，如果是，则为其添加一个Advisor增强器。 如果不是动态代理的对象，因为@Async要为方法增加代理，并转换为异步执行，故需要把原始bean转换为被AOP动态代理的bean。 问题1：@Async注解在使用第三种方法AopContext.currentProxy() 调用本类方法能生效吗？ 答案：不能生效 原因：EnableAspectJAutoProxy(exposeProxy=true)用的是 AnnotationAwareAspectJAutoProxyCreator 这个bbp 所以 EnableAspectJAutoProxy(exposeProxy=true) 这个注解的 exposeProxy=true 只针对由这个bbp创建的代理类生效，而Async注解的代理是由自己创建的 问题2：@Transactional注解在使用第三种方法AopContext.currentProxy() 调用本类方法能生效吗？ 答案：可以生效 原因：Transactional注解种的bbp是 InfrastructureAdvisorAutoProxyCreator， 而 EnableAspectJAutoProxy 会把 InfrastructureAdvisorAutoProxyCreator 替换成 AnnotationAwareAspectJAutoProxyCreator。代码在 AopConfigUtils 种的 registerOrEscalateApcAsRequired 方法 所以 Transactional注解是能享受到 EnableAspectJAutoProxy 注解的福利的 问题3：@Transactional @Async 一起用的话 调用本类方法能生效吗？ 答案：可以生效 原因：AsyncAnnotationBeanPostProcessor 优先级是最低 而AnnotationAwareAspectJAutoProxyCreator 优先级是最高，所以Async注解可以不用自己创建代理，而复用AnnotationAwareAspectJAutoProxy创建的代理。 引申：为什么引入spring cloud starter sleuth包后 @Async注解就能用AopContext.currentProxy 原因：sleuth包中定义了 @Async的切面

维基百科给的定义： 语法糖 （英语：Syntactic sugar）是由英国 计算机科学家 彼得·兰丁 发明的一个术语，指 计算机语言 中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。 简单说，语法糖就是改变了一种形式，这种形式让程序的书写更加简洁明了 定义一个函数fn，接受参数num 写一个Generator依次调用传递的参数 async函数的写法 我们发现async函数把testGen里的*替换成 async，将 yield 替换成 await而已。所以说async/await是generator的语法糖 原文： https://mp.weixin.qq.com/s/RmslOGB6gLUHNFqY5ElQRA 下一篇：JS版数据结构-栈

大家都知道，java是同步顺序执行。当需要异步执行时，需要新创建一个线程完成。 1. 使用常规的方法显示异步调用 第一步 新建 ThreadTest.java 实现 Runnable 接口 第二步 新建测试执行 当然，除了这种显式 new Thread 对象，我们通过线程池获取线程名称，这里不做演示。我们熟悉的spring 在 spring3中提供了@Async注解，来方便开发者优雅的使用异步调用。 2.使用 springboot @Async注解，优雅的实现异步调用 第一步 开启 异步调用注解。 第二步 定义线程池 第三步 创建service 测试类 TestService.java 第四步 新建 Service 实现类 ，TestServiceImpl.java 第五步 测试执行 ，执行结果 SpringBoot使用@Async优雅的异步调用就暂时记录到这里，欢迎评论区一起讨论学习。

功能描述 @Async是Spring提供的使方法异步的注解 使用方法 代码示例 已实现的TaskExecutor线程池 @Async依赖线程池，当我们未指定线程池@Async会如何选择呢？ 1. 当系统未配置任何线程池时 SpringBoot会默认添加一个coreSize=8的 ThreadPoolTaskExecutor 无界线程池，名称applicationTaskExecutor。 2. 当只配置了一个TaskExecutor线程池时 使用此线程池 3. 当只配置了一个线程池，但不是TaskExecutor线程池时 使用 SimpleAsyncTaskExecutor 线和池 4. 当有多个TaskExecutor线程池时 默认使用 SimpleAsyncTaskExecutor 线程池，如果指定就使用指定的线程池（即使不是TaskExecutor类型的线程池也可以） 注意： SimpleAsyncTaskExecutor 不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。强烈建议开发时指定线程池的名称，避免创建多个TaskExecutor实例后，使用 SimpleAsyncTaskExecutor 线和池的情况发生

最简单的使用1.启动类添加@EnableAsync注解package com.lara.springbootconfig;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.scheduling.annotation.EnableAsync;/*** @author lara*/@SpringBootApplication@EnableAsyncpublic class SpringBootConfigApplication {public static void main(String[] args) {SpringApplication.run(SpringBootConfigApplication.class, args);}}12345678910111213141516172. 方法上添加@Async，类上添加@Componentpackage com.lara.springbootconfig.task;import lombok.extern.slf4j.Slf4j;import org.springframework.scheduling.annotation.Async;import org.springframework.scheduling.annotation.AsyncResult;import org.springframework.stereotype.Component;import java.util.Random;import java.util.concurrent.Future;/*** @author lara*/@Component@Slf4jpublic class SyncTask {public static Random random =new Random();@Asyncpublic Future<String> doTaskOne() throws Exception {String threadName = Thread.currentThread().getName();log.info("{}开始做任务一",threadName);long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("{}完成任务一，耗时：{}毫秒",threadName,(end - start));return new AsyncResult<>("one done");}@Asyncpublic Future<String> doTaskTwo() throws Exception {String threadName = Thread.currentThread().getName();log.info("{}开始做任务二",threadName);long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("{}完成任务二，耗时：{}毫秒",threadName,(end - start));return new AsyncResult<>("one done");}@Asyncpublic Future<String> doTaskThree() throws Exception {String threadName = Thread.currentThread().getName();log.info("{}开始做任务三",threadName);long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("{}完成任务三，耗时：{}毫秒",threadName,(end - start));return new AsyncResult<>("one done");}@Asyncpublic Future<String> doTaskFour() throws Exception {String threadName = Thread.currentThread().getName();log.info("{}开始做任务四",threadName);long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("{}完成任务四，耗时：{}毫秒",threadName,(end - start));return new AsyncResult<>("one done");}}1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162为什么要写四个一样的方法，是为了后续做测试用。为什么方法的返回值是Future，是为了在测试方法中捕捉到所有方法执行结束。3.测试方法package com.lara.springbootconfig;import com.lara.springbootconfig.task.SyncTask;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;import org.springframework.test.context.junit4.SpringRunner;import java.util.concurrent.Future;@RunWith(SpringRunner.class)@SpringBootTestpublic class SyncTaskTest {@Autowiredprivate SyncTask syncTask;@Testpublic void test() throws Exception {Future<String> one = syncTask.doTaskOne();Future<String> two = syncTask.doTaskTwo();Future<String> three = syncTask.doTaskThree();Future<String> four = syncTask.doTaskFour();while (true) {if (one.isDone() && two.isDone() && three.isDone() && four.isDone()) {break;}}}}123456789101112131415161718192021222324252627282930314.测试结果可以看到四个方法启用了四个线程来执行。为什么会是这种结果呢？？？这是因为在我们不指定线程池的情况下，spring默认使用SimpleAsyncTaskExecutor。该线程池默认来一个任务创建一个线程。当异步任务非常多时，后果不堪设想。。。。5.自己设置执行线程池package com.lara.springbootconfig.config;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.core.task.TaskExecutor;import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;/*** @author lara* @date 2020/3/4 10:34*/@Configurationpublic class ThreadPoolConfig {@Beanpublic TaskExecutor taskExecutor(){ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setCorePoolSize(2);executor.setMaxPoolSize(3);executor.setKeepAliveSeconds(60);executor.setQueueCapacity(4);executor.setThreadNamePrefix("async-thread");return executor;}}12345678910111213141516171819202122232425上述线程池的参数含义为什么设置为2，3，4，没有为什么仅仅是为了测试使用。具体线程池参数含义以及线程的创建时机推荐阅读线程池各个参数的含义。加了上述配置后，再次运行相同的测试代码，看看结果。只有两个线程在执行任务。为什么呢？因为我们设置的核心线程是2个，前2个任务到达时，创新新的线程执行。第3个任务到达后，放进任务队列中。第4个任务到达后也放进任务队列。只有任务队列满了之后，最多创建3个线程执行任务。后续补充下SimpleAsyncTaskExecutor源码解析，解释为什么每来一个任务就创建一个线程。以及为什么自己创建的线程池名字为taskExecutor。

相对于之前Begin/End模式和事件模式，async/await模式让程序员得以用同步的代码结构进行异步编程。async/await入门很方便，但是深入理解却涉及很多领域，如线程池、同步上下文等等。我断断续续接触了几个月，稍微有一些心得：await的作用是等待异步Task完成，并不是阻塞的。举个例子，一个异步方法：<pre t="code" l="csharp">public async Task Caller(){Action0();await Method();Action3();}public async Task Method(){Action1();await Task.Delay(1000);Action2();}A. 当你在非UI线程A上执行Caller()，将完成以下几件事：[线程A]执行Action0()[线程A]调用await Method()[线程A]执行Action1()[线程A]启动任务Task.Delay(1000)，并在线程池里安插一个新任务，在Task.Delay(1000)完成后，由另一个线程执行6[线程A]去处理别的事情[线程B]执行Action2()[线程B]await Method()返回[线程B]执行Action3()</ol> 其中，线程A和线程B并不保证是同一个线程。如果你在await前后打印线程ID，你会发现ID是不同的。B. 当你在UI线程上执行Caller()，过程有了变化：[UI线程]执行Action0()[UI线程]调用await Method()[UI线程]执行Action1()[UI线程]启动任务Task.Delay(1000)，并在线程池里安插一个新任务，在Task.Delay(1000)完成后，由另一个线程执行6[UI线程]去处理别的事情[线程C]在UI线程的同步上下文中执行7（类似于在窗体类上执行Invoke()方法）[UI线程]执行Action2()[UI线程]await Method()返回[UI线程]执行Action3()</ol> 可见，当使用await方法的线程为UI线程时，程序默认会通过第6步，保证await前后是同一个线程ID。这个当然是有一定性能牺牲的（甚至会造成死锁，在D里会讨论），如果你不想在await完成后回到UI线程，见C。C. 你可以在UI线程上使用await XXX().ConfigureAwait(false)去替代await XXX()，来禁止当await XXX()结束时恢复线程。举个例子，执行下列代码是没问题的（如B里描述的）：<pre t="code" l="csharp">private async void button1_Click(object sender, EventArgs e){this.Text = "123";await Task.Delay(1000);this.Text = "321";}但是，执行下列代码就会发生“线程间操作无效”的错误：<pre t="code" l="csharp">private async void button1_Click(object sender, EventArgs e){this.Text = "123";await Task.Delay(1000).ConfitureAwait(false);this.Text = "321"; //线程间操作无效}因为执行<pre t="code" l="csharp">this.Text = "321";的线程已经不再是UI线程。D. 顺便一提，Task.Wait()方法，相比于await Task，会同步地执行Task。但是，如果你在UI线程上Wait的Task里本身又有await，那么将会产生死锁：<pre t="code" l="csharp">private void Foo(object sender, EventArgs e){this.Text = "123";Method().Wait(); //此处发生死锁this.Text = "321"; //这行永远也不会执行}private async Task Method(){await Task.Delay(1000);} 为什么呢？Method().Wait()会阻塞UI线程等待Method()完成，但是参照B过程，在await完成后，Method()完成前，是需要恢复到UI线程的，但是此时UI线程已经被阻塞了，因此死锁就发生了。 要避免这个死锁，可以参照C。E. 说出来你可能不信，上面的都是我手打的。在内容上虽然不一定严谨，但希望对楼主和其它新接触TAP的朋友有一定启发。

相对于之前Begin/End模式和事件模式，async/await模式让程序员得以用同步的代码结构进行异步编程。async/await入门很方便，但是深入理解却涉及很多领域，如线程池、同步上下文等等。我断断续续接触了几个月，稍微有一些心得：await的作用是等待异步Task完成，并不是阻塞的。举个例子，一个异步方法：12345678910111213public async Task Caller(){Action0();await Method();Action3();}public async Task Method(){Action1();await Task.Delay(1000);Action2();}A. 当你在非UI线程A上执行Caller()，将完成以下几件事：[线程A]执行Action0()[线程A]调用await Method()[线程A]执行Action1()[线程A]启动任务Task.Delay(1000)，并在线程池里安插一个新任务，在Task.Delay(1000)完成后，由另一个线程执行6[线程A]去处理别的事情[线程B]执行Action2()[线程B]await Method()返回[线程B]执行Action3()其中，线程A和线程B并不保证是同一个线程。如果你在await前后打印线程ID，你会发现ID是不同的。B. 当你在UI线程上执行Caller()，过程有了变化：[UI线程]执行Action0()[UI线程]调用await Method()[UI线程]执行Action1()[UI线程]启动任务Task.Delay(1000)，并在线程池里安插一个新任务，在Task.Delay(1000)完成后，由另一个线程执行6[UI线程]去处理别的事情[线程C]在UI线程的同步上下文中执行7（类似于在窗体类上执行Invoke()方法）[UI线程]执行Action2()[UI线程]await Method()返回[UI线程]执行Action3()可见，当使用await方法的线程为UI线程时，程序默认会通过第6步，保证await前后是同一个线程ID。这个当然是有一定性能牺牲的（甚至会造成死锁，在D里会讨论），如果你不想在await完成后回到UI线程，见C。C. 你可以在UI线程上使用await XXX().ConfigureAwait(false)去替代await XXX()，来禁止当await XXX()结束时恢复线程。举个例子，执行下列代码是没问题的（如B里描述的）：123456private async void button1_Click(object sender, EventArgs e){this.Text = "123";await Task.Delay(1000);this.Text = "321";}但是，执行下列代码就会发生“线程间操作无效”的错误：123456private async void button1_Click(object sender, EventArgs e){this.Text = "123";await Task.Delay(1000).ConfitureAwait(false);this.Text = "321"; //线程间操作无效}因为执行1this.Text = "321";的线程已经不再是UI线程。D. 顺便一提，Task.Wait()方法，相比于await Task，会同步地执行Task。但是，如果你在UI线程上Wait的Task里本身又有await，那么将会产生死锁：12345678910private void Foo(object sender, EventArgs e){this.Text = "123";Method().Wait(); //此处发生死锁this.Text = "321"; //这行永远也不会执行}private async Task Method(){await Task.Delay(1000);}为什么呢？Method().Wait()会阻塞UI线程等待Method()完成，但是参照B过程，在await完成后，Method()完成前，是需要恢复到UI线程的，但是此时UI线程已经被阻塞了，因此死锁就发生了。要避免这个死锁，可以参照C。E. 说出来你可能不信，上面的都是我手打的。在内容上虽然不一定严谨，但希望对楼主和其它新接触TAP的朋友有一定启发。

async function t(){await 123;}t().then(function(data){console.log(data);})报错：(function (exports, require, module, __filename, __dirname) { async function t(){^^^^^^^^SyntaxError: Unexpected token functionat Object.exports.runInThisContext (vm.js:78:16)at Module._compile (module.js:545:28)at Object.Module._extensions…js (module.js:582:10)at Module.load (module.js:490:32)at tryModuleLoad (module.js:449:12)at Function.Module._load (module.js:441:3)at Module.runMain (module.js:607:10)at run (bootstrap_node.js:420:7)at startup (bootstrap_node.js:139:9)at bootstrap_node.js:535:3我的代码没有问题吧，为什么会报错呢。已经是7.1.0的node了。

sync是同步，async是异步。

1、getData 执行完成 2、initData 执行完成 3、constructor 执行完成 1、调用的最外层函数中使用 async 修饰； 2、在方法体中，使用 await 修饰要发送的同步请求； 3、getData 方法是为了返回同步请求的res。toPromise，将res转成Promise对象。

MATLAB允许使用一个循环的另一循环内。一般的循环嵌套结构如下： （1）for语句 for m = 1:j for n = 1:k ; end end （2）while语句 while while end end 先运行内循环，再运行外循环。举例如下： for i=1:3 for j=1:3 fprintf("j = %d ", j);

事情的起因是微服务A通过feign调用微服务B的某个接口，报了形如下的异常 负责微服务A的工程师小张就找到负责提供该接口的工程师小李，问小李是不是改动了接口，小李一脸无辜说他最近没对这个接口做任何改动，不过小李还是说道他排查一下。 小李排查的过程如下，他先通过swagger查看他提供给A服务接口是否存在，他一查发现他在swagger上看不到他提供给A服务的接口。于是他怀疑是不是有人动了他的代码，他就去查找最近的git提交记录，发现没人动他的代码，因为项目还没发布，都在测试阶段，他就根据项目集成的git-commit-id-maven-plugin插件定位到测试目前发布具体是哪个版本。（ps：对 git-commit-id-maven-plugin感兴趣的朋友，可以查看之前的文章聊聊如何验证线上的版本是符合预期的版本）。然后他将该版本的代码下到本地进行调试，他发现代码中提供给A的接口还在，target下的class也有提供给A的接口class，但诡异的是swagger就是没显示他提供出去的接口，他一度以为是swagger出了问题，于是他用postman直接请求他提供A的接口，发现报了404。然后他就叫负责同个微服务B的同事小王，也帮忙试一下，发现结果就是404。后面没招，小李就去求助他们项目资深同事小林。 小林的排查思路如下，他先走查一下小李的接口代码，发现他提供的接口实现层的方法上加了一个@Async，示例形如下 小林凭多年的经验直觉告诉小李说，应该是@Async引起。小李很斩钉截铁的说不可能啊，他@Async很早就加了，之前接口都可以访问的，小林一看小李说得那么肯定，他也不好打击小李。于是他接下来做了如下操作，先在项目中yml配置如下参数，开启springweb日志 然后在项目中加了形如下代码，来跟踪接口bean的类型 启动控制台，看日志形如下 发现确实没打印出相关requestMapping映射信息，这可以说明一点就是小李那个接口没有绑定到springmvc映射，也就是出现404的原因。接着观察控制台打印的bean，内容形如下 这很明显这个接口bean已经被jdk动态代理给替换。小李看到控制台打印的信息，若有所思，然后说，我把@Async去掉试下。小李把@Async去掉后，再观察下控制台 通过控制台可以发现，此时接口已经绑定到springmvc映射，而且打印出bean类型是真实对象bean。小李看到这个现象，也百思不得其解，他说道他之前确实是加了@Async，接口也能正常访问。于是小林就问一句，你确定你加了@Async，异步生效了吗，小李说开启spring异步，不都是加@Async吗。小林又问了一句，你在项目中开启异步，除了加@Async，还有做什么处理吗，小李说没了，他之前在项目使用异步就都是加了@Async，也能用了好好的，小林一听，基本上知道为什么小李之前@Async，接口还能正常访问了，小林为了验证想法，就问同负责该项目的小王，说你最近有加什么异步操作吗，小王说有，小林进一步问，你是怎么做的，小王说，他先加@EnabledAsyn，开启异步，然后在业务逻辑层上的方法上加@Async注解。小李一听，说原来使用@Async还要配合@EnabledAsyn啊，他之前都不知道 接着小李说 那在controller是不是就不能使用@Async注解了？ ，小林说最好是把加@Async的逻辑挪到service层去处理，不过也不是controller就不能使用@Async注解了，接着小林为了验证这个想法，他把原来实现的接口类去掉，形如下 启动后，查看控制台 此时bean的类型如下 访问接口，打印内容如下 从控制台可以发现，都是http-nio-8080-exec-1线程触发，说明异步没生效，即@Async失效。后面对controller做了如下改造 访问接口，打印内容如下 这说明在controller其实也是可以用@Async，只是要额外做处理。所以建议是把@Async从controller中抽离出去，在新类中进行处理，示例如下 访问接口，打印内容 说明异步生效 从mvc日志 我们可以知道，controller映射处理是在RequestMappingHandlerMapping 这个类中，但具体是哪个方法进行处理呢，我们可以通过日志打印的信息，进行倒推，也可以基于spring的特性加断点调试，比如通过afterPropertiesSet这一启动扩展点调试起，就会发现RequestMappingHandlerMapping的映射处理是在 进行处理，具体是通过processCandidateBean进行处理 最终是通过detectHandlerMethods进行处理 这个里面就是做了实际注册。而执行detectHandlerMethods的前提是 即只有加了@Controller或者@RequestMapping的类会进行处理，而@RestController为啥也处理，点击 @RestController发现 他本质就是@Controller。但我们通过反射查找注解，正常只会查找一层，比如 他找到@RestController这一层，而不会找继续再找@RestController里面的@Controller，而AnnotatedElementUtils.hasAnnotation，这个注解方法就不一样，他是可以找到合并注解，即使是使用 @RestController，他还会继续找到里面的@Controller。因此这个方法对于找复合型注解很有用 当我们使用jdk动态代理时，因为父类上没加@Controller或者@RequestMapping，因此他不会被mvc进行映射处理，导致404。而使用cglib时，因为他是作为子类继承了目标类，因此他会继承目标类上的注解，因此当为cglib代理时，他会正常被mvc进行映射处理 这是因为加了@Async后，controller变成代理了，而当要异步处理方法，用this时，他使用的是目标对象，而非代理对象。这跟现在面试事务为啥事务失效的八股文基本是一个套路 本文主要讲@Async导致controller 404，同时也使@Async失效的原因。解决的推荐方法就是将@Async抽离出controller，新建一个service类进行处理。

异步调用是相对于同步调用的，同步调用是按照顺序进行执行任务，只有上一个任务执行完成下一个任务才能执行， 异步调用是指在按照顺序执行任务的过程中不需要等待任务结果的出现，就可以顺序执行下一个任务 。 异步处理的方式： SpringBoot自身没有对异步调用做很大的变动，基本还是使用SpringMVC的@Async 注解 ：在使用**@EnableWebMvc**注解的时候也可以开启异步调用，但是在SpringBoot中使用异步调用会使得SpringBoot的AutoConfig一部分功能失效。 定义一个或者多个线程池 我们使用 ThreadPoolTaskExecutor 创建线程池，其参数配置如下： 异步调用方法有两种一个是没有返回值的，一种是有返回值的，具体实现如下： 在多线程池的时候，我们需要在@Async()指定线程池名称**@Async("threadPoolTaskExecutor1")** 在单元测试用例中，注入Task对象，并在测试用例中执行 asyncMethodWithVoidReturnType_One 、 asyncMethodWithVoidReturnType_Two() 、 asyncMethodWithVoidReturnType_Three() 三个函数。 执行结果如下：

串口分为RS232,RS422,RS485，串口通常的说法是COM口，也就是电脑主机或一些打印机等设备上的9针（DB9)接口，Serial口、async口也是串口，一般称呼于路由器或交换机中，async口只可工作在异步方式下，速率最大115.2K；Serial口可工作在同步与异步方式下，同步方式时速率最大2M，异步方式时115.2K。

上述注解的作用是注册了一个Bean，而这个bean实现了 BeanPostProcessor 接口，可以参与Bean的初始化。 该注解可以定义一些属性，且“导入”了一个 AsyncConfigurationSelector 。 该类会注册 ProxyAsyncConfiguration 。 即注册了 AsyncAnnotationBeanPostProcessor ，可以完成bean的代理。 AsyncAnnotationBeanPostProcessor 仅仅实现的是 setBeanFactory 方法。在此方法中，定义了 AsyncAnnotationAdvisor 增强器。 代理的实现，依赖的是 AbstractAdvisingBeanPostProcessor 实现的 BeanPostProcessor 定义的方法。 在 上文 中，由于多个 自动代理器 均代理同一个bean时，可能存在bean的二次代理问题。当然 AbstractAdvisingBeanPostProcessor 明显考虑到这个问题。 从Spring命名分析： AbstractAdvisingBeanPostProcessor 抽象增强后置处理器。 而事务依赖 AbstractAutoProxyCreator 抽象的自动代理处理器。 当然，我们使用了 @Async 使用的是 AsyncAnnotationBeanPostProcessor 完成处理，由2中分析，我们可知子类重写了 isEligible / prepareProxyFactory / setBeanFactory 方法。继续分析子类重写的方法。 Spring提供了一个工具方法， AopUtils.canApply() 方法，当然，这个方法以及可以脱离Spring容器使用： 将源码关键部分抽取出来，重点分析 Spring如何校验bean是否能被 @Async 增强。 启动项目，查看bean是否能被增强。 校验方法或类上是否存在@Async注解。 源码位置：org.springframework.aop.support.MethodMatchers.UnionMethodMatcher 使用org.springframework.aop.support.annotation.AnnotationClassFilter#matches 进行验证类上是否存在 @Async 注解？ checkInherited 意思是是否检查父类上存在注解？默认 true 源码： org.springframework.aop.support.annotation.AnnotationMethodMatcher#matches AbstractAdvisingBeanPostProcessor 是一个增强 BeanPostProcessor ，在处理器内部定义了 Advisor 。 是在 org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor#setBeanFactory 该方法中定义了Advisor。 源码： org.springframework.aop.framework.autoproxy.AbstractBeanFactoryAwareAdvisingPostProcessor 配置 ProxyFactory ，以便生成Proxy代理对象。 this 对象即AsyncAnnotationBeanPostProcessor。因为实现了 ProxyConfig 接口（代理配置类）。所以可以影响 ProxyFactory 的创建过程。 当然， 开发者可以修改 AsyncAnnotationBeanPostProcessor 的BeanDefinition，定义Proxy对象。

这是因为你这a、b、c函数并没有返回值（setTimeout的返回值不等于是函数的返回值），所以当然是undefined。而且按照ES7的语法规定，a、b、c函数的返回值必须是promise对象。下面是正确的代码：async function a() { return new Promise(res=>{ setTimeout(()=>res("a"),3000) })}async function b() { return new Promise(res=>{ setTimeout(()=>res("b"),2000) })}async function c() { return new Promise(res=>{ setTimeout(()=>res("c"),1000) })}async function d() { let a1 = await a() let b1 = await b() let c1 = await c() console.log(a1,b1,c1)}d()

当前方法也要声明为async才行

官网的例子HeaderElementIterator it = new BasicHeaderElementIterator( response.headerIterator("Set-Cookie"));while (it.hasNext()) { HeaderElement elem = it.nextElement(); System.out.println(elem.getName() + " = " + elem.getValue()); NameValuePair[] params = elem.getParameters(); for (int i = 0; i < params.length; i++) { System.out.println(" " + params[i]); }}然后在logcat中看到

await只能放在async函数里面 但需要猜测两次以上大小时，得用promise.all或promise.race 因为更像同步函数。

一、在JavaEE项目中搭建环境1. 导入相关jar包2. 搭建相关的包和类3.类中的方法简单实现User:声明以下属性，并实现无参构造器和有参构造器，以及各自的get和set方法UserDao:UserDaoImpl:JsonServlet：protected void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {// 来自于数据库UserDao daoImpl = new UserDaoImpl();List entities = daoImpl.findAll();// 把List集合转换成一个json的数据格式JSONArray jsonArray = JSONArray.fromObject(entities);response.setContentType("application/json");// 响应类型 json的数据response.getWriter().write(jsonArray.toString());response.getWriter().close();}protected void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {doGet(request, response);}

Flink处理数据时候，遇到比较耗时的操作时，需要异步处理数据。 例子如下： 说明： 1、AsyncDataStream有2个方法，unorderedWait表示数据不需要关注顺序，处理完立即发送，orderedWait表示数据需要关注顺序，为了实现该目标，操作算子会在该结果记录之前的记录为发送之前缓存该记录。这往往会引入额外的延迟和一些Checkpoint负载，因为相比于无序模式结果记录会保存在Checkpoint状态内部较长的时间。 2、Timeout配置，主要是为了处理死掉或者失败的任务，防止资源被长期阻塞占用。 3、最后一个参数Capacity表示同时最多有多少个异步请求在处理，异步IO的方式会导致更高的吞吐量，但是对于实时应用来说该操作也是一个瓶颈。限制并发请求数，算子不会积压过多的未处理请求，但是一旦超过容量的显示会触发背压。 该参数可以不配置，但是默认是100。

使用 async-await 等待异步操作完成的时候，如果前后两个异步操作不存在依赖关系，同时触发应该是更好的方案。 因为 await 后面必须跟一个 Promise 实例，于是可以用 Promise.all() 这个方法把多个 Promise 实例合并成一个 Promise 实例。 Promise.all() 接收一个部署了 Iterator 的对象（例如：数组、Set），每个成员都必须是 Promise 实例，且只有当每个成员的状态都是 fulfilled 的时候，总实例的状态才是 fulfilled ，否则是 rejected 。 Promise.all() 用法示例： async-await 同时触发多个异步操作示例：

首先，你这个地方跨域了，其次，async：false后就是同步

string returnstr ="";int[] arr = new int[]{l,r,s,a,c};Array.sort(arr);for(int i=0;i<3;i++){if(arr[i]==l){returnstr +="l";}else if(arr[i]==r){returnstr +="r";}else if(arr[i]==s){returnstr +="s";}else if(arr[i]==a){returnstr +="a";}else if(arr[i]==c){returnstr +="c";}}retrurn returnstr ;

看一下逗号和冒号是不是中文的

先安装async包：npm install async在程序中用 var async = require("async") 引用。