在计算机编程中，**async/await模式**是一种存在于许多编程语言中的语法特性。这种模式使得异步非阻塞函数逻辑可以用一种类似于同步函数的方式进行构造。在语义上，它与协程的概念相关，且通常也使用类似的技术实现。该模式大都是为了让程序能够在等待一个异步的长耗时操作完成的同时，也可以正常执行代码，它通常表现为Promises或者类似的形式。

这一特性出现在C# 5.0、C++20、 Python 3.5、 F#、 Hack、 Julia、 Dart、 Kotlin 1.1、 Rust 1.39、 Nim 0.9.4、 JavaScript ES2017、 Swift 5.5 和Zig中。对于Scala则出现在一些beta版本、实验版本的插件和特定的一些实现中。

历史
--

F# 2.0（2007）中添加了含await点的异步逻辑。这对于后来添加到C#中的async/await机制有所启发。

微软在2011年的Async CTP（**C**ommunity **T**echnology **P**review，社区技术预览版）C#中首次添加了async/await，随后在2012年的C# 5中正式发布了这一机制。

Haskell的主要开发者Simon Marlow（英语：）于2012年开发了async包。

Python 3.5（2015）中支持了async/await，加入两个新的关键字`async`和`await`。

TypeScript 1.7（2015）中支持了async/await。

JavaScript在2017年支持了async/await，作为ES2017标准的一部分。

Rust 1.39.0（2019）中支持了async/await，加入一个关键字`async`和一个惰性求值`await`。

C++20（2020）中支持了async/await，加入三个新的关键字`co_return`、`co_await`和`co_yield`。

Swift 5.5（2021）中支持了async/await，加入三个新的关键字`async`、`await`和`actor`，其中`actor`来自于同时期发布的对演员模型的一种具体的实现。这一模型中直接用到了async/await

一个C#的例子
-------

下面的函数用于从一个URI上下载数据，然后返回这个数据的长度，其中就是用了async/await模式。

```
public async Task<int> FindPageSizeAsync(Uri uri) 
{
 var client = new HttpClient();
 byte[] data = await client.GetByteArrayAsync(uri);
 return data.Length;
}

```
为了便于理解，我们将上面的这一函数称为**主函数**。注意下文中的Promise是一个概念上统称，而不一定是具体存在的一种对象。

1. 当函数被async关键字标记时，它会被编译器认为是异步的。这样的函数中可能会有若干个await表达式，它们可将结果绑定到Promise对象上。主函数就是一个典型的异步函数。
2. 主函数的返回类型 `Task<T>`（其中T为泛型）是C#对Promise概念的一种实现，在代码中`Task<int>`表明该Promise对应的实际结果是`int`类型的。
3. 当主函数被执行时，首先一个新的HttpClient实例会被赋给client。
4. 接下来await后紧跟的一句表达式执行了client上的**异步**方法`GetByteArrayAsync(uri)`，它会返回一个`Task<byte[]>`。由于该方法是异步的，它并不会等到下载完成才返回，而是以某种非阻塞的方式（例如后台进程）开始下载，然后马上返回一个没有被**resolve**也没有被**reject**的`Task<byte[]>`到主函数中。在这里，resolve和reject可以理解为Task对象上的两个自带的方法，resolve(x)表示执行完成，reject(x)表示执行失败，二者都表示执行结束，因而都可用于最终的传值。
5. 由于该表达式返回的`Task<byte[]>`前有await，接下来主函数会直接返回一个类似于之前Task对象的`Task<int>`到其调用者。显然，其调用者并不会被阻塞。
6. 当`GetByteArrayAsync(uri)`下载结束后，它会使用其下载的数据**resolve**它所返回的那个Task，即上文中的`Task<byte>`。**Resolve**会触发一个回调函数，使得主函数继续向下执行`return data.Length`。
7. 然后与`GetByteArrayAsync(uri)`的行为类似，主函数也会使用`return`语句返回的值来**resolve**它所返回的`Task<int>`，触发一个回调函数，使得其调用者能够开始使用这一具体值。

异步函数内部可以根据需要使用多个await语句，每一个语句都会以相同的方式进行处理（实际上只有第一个await语句会返回Promise，其余的await都用机制类似的内部回调函数实现）。对于返回的Promise对象，算法中亦可以对其直接进行处理（例如先保存起来），从而实现先执行其它任务（包括触发新的异步Task），等到需要相关结果的时候才使用await语句处理Promise对象，拿到结果。

除了直接await之外，也有一些可以批量处理Promise对象的函数，比如C#中的`Task.WhenAll()`函数，它会返回一个`Task`（无值Task，可以理解为`Task<void>`）。这个被返回的`Task`会在`Task.WhenAll()`方法参数中提供的所有的Promise被resolve以后resolve。还有一些Promise返回类型支持通常async/await模式不会用到的一些方法，例如对Promise设置多个结果的回调函数、监听长耗时Task的执行进程等。

在C#和许多其它语言中，async/await模式并不是运行时的核心组成部分，而实际上会在编译的时候使用Lambda表达式或者续体来实现。例如上面的C#代码很可能会被编译器先转换成下面的代码，然后才被转换成字节码。

```
public Task<int> FindPageSizeAsync(Uri uri) 
{
 var client = new HttpClient();
 Task<byte[]> dataTask = client.GetByteArrayAsync(uri);
 Task<int> afterDataTask = dataTask.ContinueWith((originalTask) => {
 return originalTask.Result.Length;
 });
 return afterDataTask;
}

```
也正因此，如果某个函数需要返回一个Promise对象，但是其本身并不需要进行任何的await求值，那么它并不需要在函数声明前面加上async来让自己成为一个异步函数，而是可以直接返回一个Promise对象。例如，使用C#的`Task.FromResult()`方法来返回一个马上resolve的`Task`，或者直接如同地铁换乘一样将其它函数所提供的`Task`直接原样返回。

不过对于这项功能必须要注意的一项是，尽管在异步函数内部的逻辑长得很像同步的形式，这些逻辑实际上是非阻塞的，甚至可能是多线程的。所以在await语句等待Promise被resolve的时候，可能会发生许多侵入性的事件。比如下面的代码，如果没有await，那么将始终执行成功，但是如果使用了async/await模式，就可能会出现`state.a`发生改变（被其它逻辑）的情况。

```
var a = state.a;
var client = new HttpClient(); // 与a无关的语句
var data = await client.GetByteArrayAsync(uri); // 与a无关的语句
Debug.Assert(a == state.a); // ★这个语句可能会出现错误，因为state.a可能在await的过程中被其它逻辑篡改。
return data.Length;

```

在F#中的使用
-------

F#中的异步逻辑的具体实现是计算表达式。具体使用时并不需要加上特殊的标识符，例如`async`。在代码逻辑中，使用一个感叹号（`!`）来开始异步操作。

从URL下载数据的异步函数逻辑如下：

```
let asyncSumPageSizes (uris: #seq<Uri>) : Async<int> = async {
 use httpClient = new HttpClient()
 let! pages = 
 uris
 |> Seq.map(httpClient.GetStringAsync >> Async.AwaitTask)
 |> Async.Parallel
 return pages |> Seq.fold (fun accumulator current -> current.Length + accumulator) 0
}

```

在C#中的使用
-------

微软将C#中的async/await模式称作"以任务为基础的异步模式"（Task-based Asynchronous Pattern，TAP）。异步函数的返回值通常包括`void`、`Task` 、`Task<T>`、 `ValueTask`和`ValueTask<T>`。代码中还可以利用异步函数构造器（async method builders）自行定义异步函数的返回值类型，不过这一场景高阶且少见。返回`void`的异步函数通常应该是事件监听器，对于一般的函数则应该返回`Task`对象，因为它能够提供更加直观的异常处理。

要在函数中使用`await`，必须在函数声明前加上`async`关键字。当需要函数返回`Task<T>`类型的值时，函数声明前要加上`async`关键字，同时应当返回`T`或兼容的类型，而非`Task<T>`本身；随后编译器就会将返回的`T`类型包装为`Task<T>`泛型。不过，当非异步函数（没有使用`async`声明的函数）返回`Task<T>`时，其值也可以被`await`。

下列函数代码将使用`await`从URL下载数据。该函数的逻辑用`await`实现了同时触发多个任务，无需等待其完成，这使得下一个任务无需在上一个任务完成之后才触发（这是**同步**的逻辑）。

```
public async Task<int> SumPageSizesAsync(IEnumerable<Uri> uris) 
{
 var client = new HttpClient();
 int total = 0;
 var loadUriTasks = new List<Task<byte[]>>();

 foreach (var uri in uris)
 {
 var loadUriTask = client.GetByteArrayAsync(uri);
 loadUriTasks.Add(loadUriTask );
 }

 foreach (var loadUriTask in loadUriTasks)
 {
 statusText.Text = $"已找到 {total} 个字节...";
 var resourceAsBytes = await loadUriTask;
 total += resourceAsBytes.Length;
 }

 statusText.Text = $"共找到 {total} 个字节。";

 return total;
}

```

在Scala中的使用
----------

Scala中有一个实验性的拓展Scala-async可以实现async/await模式。它提供了一个名为`await`的特殊函数。与C#不同的是，Scala中的异步逻辑并不需要用`async`来标记。通过Scala-async，可以直接将异步逻辑用`async`函数调用的形式包围起来。

### 这是如何实现的

Scala-async所提供的`async`实际上是通过宏来实现的。编译器会调用不同的代码，然后产生一个有限状态机（通常认为这比单子实现更高效，但是更难以编写）。

在Python中的使用
-----------

在Python中的使用，在语法上与C#、JavaScript等类似。

```
import asyncio

async def main():
    print("hello")
    await asyncio.sleep(1)
    print("world")

asyncio.run(main())

```

在JavaScript中的使用
---------------

JavaScript中的`await`运算符只能用于`async`标注的函数中，或者用于模块的最顶层。

如果`await`运算符后跟参数为Promise对象，那么函数逻辑会在该Promise对象被resolve之后继续执行，或者在它被reject以后抛出异常（可以进行异常处理）；如果`await`运算符后跟参数不是Promise对象，那么该值会被直接返回（不会等待）。

许多JavaScript库提供了可返回Promise对象的函数，它们都可以被`await`——只要符合JavaScript中的Promise规范。JQuery中函数返回的Promise在3.0版本以后才达到了Promises/A+兼容度。

下面是一个使用例：

```
async function createNewDoc() {
 let response = await db.post({}); // post a new doc
 return db.get(response.id); // find by id
}

async function main() {
 try {
 let doc = await createNewDoc();
 console.log(doc);
 } catch (err) {
 console.log(err);
 }
}
main();

```
Node.js 8 中包含的一样工具可将标准库中利用回调模式编写的函数当作Promise来使用。

在C++中的使用
--------

C++ 20中正式支持了await（在C++中是`co_await`）。GCC、MSVC编译器支持async/await模式，包括协程以及相关的关键字例如`co_await`。Clang对此有部分支持。

值得注意的是`std::promise`和`std::future`虽然看起来像是可以被await求值的对象，但是实际上它们并没有实现任何类似于*从协程中返回的值*或者*可被await的对象*的相关属性；要使返回对象可以被await求值，必须在返回的对象类型上实现一系列的公共成员函数，例如`await_ready`、`await_suspend`和`await_resume`等。具体细节可以查看相关的参考。

```
#include <iostream>
#include "CustomAwaitableTask.h"

using namespace std;

CustomAwaitableTask<int> add(int a, int b)
{
 int c = a + b;
 co\_return c;
}

CustomAwaitableTask<int> test()
{
 int ret = co\_await add(1, 2);
 cout << "return "<< ret << endl;
 co\_return ret;
}

int main()
{
 auto task = test();

 return 0;
}

```

在C语言中的使用
--------

C语言没有对await/async的官方支援。

某些协程库（例如s\_task （页面存档备份，存于））通过宏定义的方式，
实现了和其他语言类似的await/async的强制性语义要求，即：

```
1. 必须在async标注的函数内，才能调用await；
2. 等待一个标注为aysnc的函数，调用该函数时需要加上await；
```

```
#include <stdio.h>
#include "s\_task.h"

//定义协程任务需要的栈空间
int g\_stack\_main[64 \* 1024 / sizeof(int)];
int g\_stack0[64 \* 1024 / sizeof(int)];
int g\_stack1[64 \* 1024 / sizeof(int)];

void sub\_task(\_\_async\_\_, void\* arg) {
 int i;
 int n = (int)(size\_t)arg;
 for (i = 0; i < 5; ++i) {
 printf("task %d, delay seconds = %d, i = %d\n", n, n, i);
 s\_task\_msleep(\_\_await\_\_, n \* 1000); //等待一点时间
 }
}

void main\_task(\_\_async\_\_, void\* arg) {
 int i;

 //创建两个子任务
 s\_task\_create(g\_stack0, sizeof(g\_stack0), sub\_task, (void\*)1);
 s\_task\_create(g\_stack1, sizeof(g\_stack1), sub\_task, (void\*)2);

 for (i = 0; i < 4; ++i) {
 printf("task\_main arg = %p, i = %d\n", arg, i);
 s\_task\_yield(\_\_await\_\_); //主动让出cpu
 }

 //等待子任务结束
 s\_task\_join(\_\_await\_\_, g\_stack0);
 s\_task\_join(\_\_await\_\_, g\_stack1);
}

int main(int argc, char\* argv) {

 s\_task\_init\_system();

 //创建一个任务
 s\_task\_create(g\_stack\_main, sizeof(g\_stack\_main), main\_task, (void\*)(size\_t)argc);
 s\_task\_join(\_\_await\_\_, g\_stack\_main);
 printf("all task is over\n");
 return 0;
}

```

参考文献
----

1. 1 2 3 4 5 6  Skeet, Jon.. Manning. ISBN 978-1617294532.
2. ↑ .  [2019-11-07]. （原始内容存档于2023-09-02） （英语）.
3. ↑ .  [2020-01-19]. （原始内容存档于2023-08-01） （英语）.
4. ↑ . docs.swift.org.  [2021-09-28]. （原始内容存档于2022-03-01）.
5. ↑ .  [2023-06-23]. （原始内容存档于2022-03-31）.
6. 1 2 . GitHub.  [20 October 2013]. （原始内容存档于2017-03-03）.
7. ↑  Syme, Don; Petricek, Tomas; Lomov, Dmitry.. Springer Link. Lecture Notes in Computer Science **6539**. 2011: 175–189  [2021-04-29]. ISBN 978-3-642-18377-5. doi:10.1007/978-3-642-18378-2\_15. （原始内容存档于2023-06-23） （英语）.
8. ↑ . ACM Digital Library.  [2021-04-29]. （原始内容存档于2023-06-23） （英语）.
9. ↑  Hejlsberg, Anders.. Channel 9 MSDN. Microsoft.  [5 January 2021]. （原始内容存档于2021-05-16） （英语）.
10. ↑ . Hackage.  [2023-06-23]. （原始内容存档于2023-06-23）.
11. ↑ . docs.python.org.  [5 January 2021]. （原始内容存档于2016-06-18）.
12. ↑  Gaurav, Seth.. TypeScript. Microsoft. 30 November 2015  [5 January 2021]. （原始内容存档于2023-07-24）.
13. ↑  Matsakis, Niko.. blog.rust-lang.org. Rust Blog.  [5 January 2021]. （原始内容存档于2020-06-03） （英语）.
14. ↑ .  [2023-06-23]. （原始内容存档于2023-06-23）.
15. ↑  Skeet, Jon.. Manning. ISBN 978-1617294532.
16. 1 2 3 4 5  Albahari, Joseph.. O'Reilly. ISBN 978-1-098-12195-2.
17. ↑ . Microsoft.  [28 September 2020]. （原始内容存档于2022-09-03）.
18. ↑  Price, Mark J.. Packt. ISBN 978-1-098-12195-2.
19. ↑  Tepliakov, Sergey.. Developer Support. 2018-01-11  [2022-10-30]. （原始内容存档于2023-06-04） （美国英语）.
20. ↑  Stephen Cleary, Async/Await - Best Practices in Asynchronous Programming （页面存档备份，存于）
21. ↑ .  [2 May 2017]. （原始内容存档于2017-06-02）.
22. ↑ .  [2 May 2017]. （原始内容存档于2021-01-21）.
23. ↑ .  [12 November 2015]. （原始内容存档于2015-11-15）.
24. ↑  Foundation, Node.js.. Node.js.  [2023-06-27]. （原始内容存档于2023-10-03）.
25. ↑ .  [2023-06-27]. （原始内容存档于2021-03-25）.