AsyncIO on Dapeng Zhang

Python asyncio协程 - 简单等待（二）

Wed, 30 Jul 2025 11:04:04 +0800

asyncio协程 - 简单等待（二）

语法如下


asyncio.as_completed(aws, *, loop=None, timeout=None)

官方文档解释

并发地运行 aws 集合中的可等待对象。返回一个协程的迭代器。所返回的每个协程可被等待以从剩余的可等待对象集合中获得最早的下一个结果。

如果在所有 Future 对象完成前发生超时则将引发 asyncio.TimeoutError。

比如下面的示例


for coro in as_completed(aws):
 earliest_result = await coro
 # ...

我们看一个完整的示例


import asyncio
import time

async def delay_timer(delay):
 await asyncio.sleep(delay)
 print(f"delay for {delay} seconds")
 return delay

async def main():
 print(f"start at {time.strftime('%X')}")
 tasks = [delay_timer(i) for i in range(10)]
 for p in asyncio.as_completed(tasks):
 res = await p

 print(f"end at {time.strftime('%X')}")

asyncio.run(main())

运行结果如下


$ python main.py
start at 22:23:48
delay for 0 seconds
delay for 1 seconds
delay for 2 seconds
delay for 3 seconds
delay for 4 seconds
delay for 5 seconds
delay for 6 seconds
delay for 7 seconds
delay for 8 seconds
delay for 9 seconds
end at 22:23:57

Python asyncio协程 - 简单等待（一）

Wed, 30 Jul 2025 11:04:01 +0800

asyncio协程 - 简单等待

语法如下

coroutine asyncio.wait(aws, *, loop=None, timeout=None, return_when=ALL_COMPLETED)¶

官方文档简介如下

并发运行 aws 指定的可等待对象并阻塞线程直到满足 return_when 指定的条件。

返回两个 Task/Future 集合: (done, pending)。

用法如下

done, pending = await asyncio.wait(aws)

如指定 timeout (float 或 int 类型) 则它将被用于控制返回之前等待的最长秒数。

请注意此函数不会引发 asyncio.TimeoutError。当超时发生时，未完成的 Future 或 Task 将在指定秒数后被返回。

return_when 指定此函数应在何时返回。它必须为以下常数之一:

常数	描述
`FIRST_COMPLETED`	函数将在任意可等待对象结束或取消时返回。
`FIRST_EXCEPTION`	函数将在任意可等待对象因引发异常而结束时返回。当没有引发任何异常时它就相当于 `ALL_COMPLETED`。
`ALL_COMPLETED`	函数将在所有可等待对象结束或取消时返回。

与 wait_for() 不同，wait() 在超时发生时不会取消可等待对象。

注意

wait() 会自动将协程作为任务加入日程，以后将以 (done, pending) 集合形式返回显式创建的任务对象。因此以下代码并不会有预期的行为:

import asyncio

async def num():
 return 42

async def main():

 coro = num()
 done, pending = await asyncio.wait({coro})

 if coro in done:
 # 这里将不会运行
 print(coro)

asyncio.run(main())

上面的代码将不会运行

如果将上面的代码修改为下面的代码

import asyncio

async def num():
 return 42

async def main():

 coro = asyncio.create_task(num())
 done, pending = await asyncio.wait({coro})

 if coro in done:
 # 这里将不会运行
 print(coro)

asyncio.run(main())

上面的代码运行结果类似如下

$ python main.py
<Task finished coro=<num() done, defined at main.py:14> result=42>

Python asyncio协程 - 超时

Wed, 30 Jul 2025 11:03:58 +0800

先回忆下之前关于asyncio的学习（基本忘的差不多了）

1、gather（集合，感觉类似于collect的意思），实际上是用来并发运行任务的

2、writable object（可等待对象）

3、Task（任务）

4、sleep（休眠）

好了，上面的几个特性，我觉得是在asyncio中用的比较多的

下面看下超时和屏蔽取消的特性

先看下屏蔽取消

屏蔽取消

这个屏蔽取消主要是针对gather里面的特性，因为在使用gather的时候，会遇到一个情况就是取消并发任务中的某个任务，这个时候就需要用到取消的动作，

既然有取消，就会有屏蔽取消的情况，这个功能果然与矛盾相关

看下如何屏蔽取消，首先是语法

awaitable asyncio.shield(aw, * , loop=None)

然后在使用的时候，像下面这样调用

await asyncio.shield(some_func())

下面看个简单的实例

import asyncio

async def div(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 await asyncio.sleep(2)
 print(f"{x} / {y} = {x/y}")
 return x / y

async def main():
 task1 = asyncio.shield(div(1, 2))
 task2 = asyncio.create_task(div(2, 3))
 task3 = asyncio.create_task(div(3, 4))
 res = asyncio.gather(task1, task2, task3, return_exceptions=True)

 task1.cancel()
 task2.cancel()
 print(await res)

asyncio.run(main())

运行后得到的结果如下

$ python main.py
1 / 2 = 0.5
3 / 4 = 0.75
[CancelledError(), CancelledError(), 0.75]

超时（Timeouts）

coroutine asyncio.wait_for(aw, timeout, *, loop=None)

超时使用的情况也是比较多的

先看下官方的解释

等待 aw 可等待对象完成，指定 timeout 秒数后超时。

如果 aw 是一个协程，它将自动作为任务加入日程。

timeout 可以为 None，也可以为 float 或 int 型数值表示的等待秒数。如果 timeout 为 None，则等待直到完成。

如果发生超时，任务将取消并引发 asyncio.TimeoutError.

要避免任务取消，可以加上 shield()。

函数将等待直到目标对象确实被取消，所以总等待时间可能超过 timeout 指定的秒数。

如果等待被取消，则 aw 指定的对象也会被取消。

Deprecated since version 3.8, will be removed in version 3.10: loop 形参。

下面看个简单的例子

import asyncio

async def sleep(sleep_time):
 await asyncio.sleep(sleep_time)
 print(f'after {sleep_time} , sleep over')

async def main():

 try:
 await asyncio.wait_for(sleep(3600), 1.0)
 except asyncio.TimeoutError as timeout:
 print('timeout!')

asyncio.run(main())

运行后得到的结果如下

$ python main.py
timeout!

使用方法也比较简单

我能想到的可能的场景

比如，数据库SQL查询的时候

Python asyncio协程 - gather(5)

Wed, 30 Jul 2025 11:03:49 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第六点的特性

如果 aws 序列中的任一 Task 或 Future 对象被取消，它将被当作引发了 CancelledError 一样处理 – 在此情况下 gather() 调用不会被取消。这是为了防止一个已提交的 Task/Future 被取消导致其他 Tasks/Future 也被取消。

前面的几篇文章分别记录了gather的五个特性，基本上都在说gather中的方法执行的时候被取消会发生什么异常，这个是最后的一个特性

下面先记录下一个简单的例子来说明问题

import asyncio

async def div(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 await asyncio.sleep(1)
 print(f"{x} / {y} = {x/y}")
 return x / y

async def main():
 task1 = asyncio.create_task(div(0, 2))
 task2 = asyncio.create_task(div(1, 2))
 task3 = asyncio.create_task(div(3, 4))

 t = asyncio.gather(task1, task2, task3, return_exceptions=True)

 task1.cancel()

 print(await t)

asyncio.run(main())

运行结果如下

$ python main.py
1 / 2 = 0.5
3 / 4 = 0.75
[CancelledError(), 0.5, 0.75]

Python asyncio协程 - gather(4)

Wed, 30 Jul 2025 11:03:39 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第五点的特性

如果 gather() 被取消，所有被提交 (尚未完成) 的可等待对象也会被取消。

前面的几篇文章分别记录了gather的四个特性，为了下面的记录能够比较好的理解，请先回顾

下面先记录下一个简单的例子来说明问题


import asyncio

async def fac(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 await asyncio.sleep(5)
 print(f"{x} / {y} = {x/y}")
 return x / y

async def main():
 t = asyncio.gather(fac(0, 2), fac(1, 2), fac(3, 4))
 await asyncio.sleep(1)
 t.cancel()
 await t

asyncio.run(main())

运行后得到的结果如下

$ python main.py
1 / 2 = 0.5
3 / 4 = 0.75
Traceback (most recent call last):
 File "main.py", line 29, in <module>
 asyncio.run(main())
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/runners.py", line 43, in run
 return loop.run_until_complete(main)
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/base_events.py", line 579, in run_until_complete
 return future.result()
 File "main.py", line 26, in main
 await t
 File "main.py", line 15, in fac
 raise ZeroDivisionError
ZeroDivisionError

似乎看不出什么效果

我们将gather的代码修改如下，将sleeo的时间增加到5秒

import asyncio

async def fac(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 await asyncio.sleep(5)
 print(f"{x} / {y} = {x/y}")
 return x / y

async def main():
 t = asyncio.gather(fac(0, 2), fac(1, 2), fac(3, 4))
 await asyncio.sleep(1)
 t.cancel()
 await t

asyncio.run(main())

运行后得到的结果如下

$ python main.py
Traceback (most recent call last):
 File "main.py", line 30, in <module>
 asyncio.run(main())
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/runners.py", line 43, in run
 return loop.run_until_complete(main)
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/base_events.py", line 579, in run_until_complete
 return future.result()
 File "main.py", line 27, in main
 await t
 File "main.py", line 16, in fac
 raise ZeroDivisionError
ZeroDivisionError

从这里可以很清楚的了解这一特性

只要有一个是异常的后面的尚未执行的也会被取消

Python asyncio协程 - gather(3)

Wed, 30 Jul 2025 11:03:35 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第三点的特性

如果 return_exceptions 为 False (默认)，所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象不会被取消并将继续运行。

先简单的看个例子

import asyncio

async def fac(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 print(f"{x}/{y}={x/y}")
 return x / y

async def main():
 res = await asyncio.gather(fac(1, 2), fac(2, 3), fac(0, 2))

 print(res)

asyncio.run(main())

运行后结果如下

$ python main.py
1/2=0.5
2/3=0.6666666666666666
Traceback (most recent call last):
 File "main.py", line 28, in <module>
 asyncio.run(main())
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/runners.py", line 43, in run
 return loop.run_until_complete(main)
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/base_events.py", line 579, in run_until_complete
 return future.result()
 File "main.py", line 23, in main
 res = await asyncio.gather(fac(1, 2), fac(2, 3), fac(0, 2))
 File "main.py", line 16, in fac
 raise ZeroDivisionError
ZeroDivisionError

如果我们将return_exceptions换个参数加上再试下

代码如下

import asyncio

async def fac(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 print(f"{x}/{y}={x/y}")
 return x / y

async def main():
 res = await asyncio.gather(fac(1, 2),
 fac(2, 3),
 fac(0, 2),
 return_exceptions=True)

 print(res)

asyncio.run(main())

运行后结果如下

$ python main.py
1/2=0.5
2/3=0.6666666666666666
[0.5, 0.6666666666666666, ZeroDivisionError()]

上面的代码例子就是要说的第四点特性

如果 return_exceptions 为 True，异常会和成功的结果一样处理，并聚合至结果列表。

Python asyncio协程 - gather(2)

Wed, 30 Jul 2025 11:03:32 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第二点的特性

如果所有可等待对象都成功完成，结果将是一个由所有返回值聚合而成的列表。结果值的顺序与 aws 中可等待对象的顺序一致。

我们看一个例子理解下

import asyncio

async def fac(name, num):
 total = 1
 for i in range(2, num + 1):
 await asyncio.sleep(1)
 total *= i

 return total

async def main():
 gather_res = await asyncio.gather(fac('xiao wang', 2), fac('xiao li', 3),
 fac('xiao zhang', 4))

 print(gather_res)

asyncio.run(main())

ok，运行后得出的结果如下

$ python main.py
[2, 6, 24]

从输出的结果中可以看出，这个是一个列表，而且是一个有序的列表，正好跟我们传值的顺序一致

下面换个调用顺序测试下

代码如下

import asyncio

async def fac(name, num):
 total = 1
 for i in range(2, num + 1):
 await asyncio.sleep(1)
 total *= i

 return total

async def main():
 gather_res = await asyncio.gather(fac('xiao wang', 4), fac('xiao li', 3),
 fac('xiao zhang', 2))

 print(gather_res)

asyncio.run(main())

运行后的结果如下

$ python main.py
[24, 6, 2]

Python asyncio协程 - gather(1)

Wed, 30 Jul 2025 11:03:28 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第一点的特性

并发执行aws参数指定的可等待（awaitable）对象序列。

如果 aws 中的某个可等待对象为协程，它将自动作为一个任务加入日程。

可以理解为如果 aws 序列中的某个 awaitable 对象是一个协程,则自动将这个协程封装为 Task对象进行处理

看下面的代码

import asyncio

async def fac(name, number):
 num = 1

 for i in range(2, number + 1):
 print(f"Task {name}: Compute fac({i})")
 await asyncio.sleep(1)
 num *= i

 print(f"Task {name}: fac({number}) = {num}")

async def main():
 await asyncio.gather(fac("xiao wang", 2), fac("xiao li", 3),
 fac("xiao zhang", 4))

asyncio.run(main())

运行下看下结果

$ python main.py
Task xiao wang: Compute fac(2)
Task xiao li: Compute fac(2)
Task xiao zhang: Compute fac(2)
Task xiao wang: fac(2) = 2
Task xiao li: Compute fac(3)
Task xiao zhang: Compute fac(3)
Task xiao li: fac(3) = 6
Task xiao zhang: Compute fac(4)
Task xiao zhang: fac(4) = 24

再来对比下下面的代码

import asyncio

async def fac(name, number):
 num = 1

 for i in range(2, number + 1):
 print(f"Task {name}: Compute fac({i})")
 await asyncio.sleep(1)
 num *= i

 print(f"Task {name}: fac({number}) = {num}")

async def main():
 task1 = asyncio.create_task(fac("xiao wang", 2))
 task2 = asyncio.create_task(fac("xiao li", 3))
 task3 = asyncio.create_task(fac("xiao zhang", 4))

 await asyncio.gather(task1, task2, task3)

asyncio.run(main())

运行看下效果

$ python main.py
Task xiao wang: Compute fac(2)
Task xiao li: Compute fac(2)
Task xiao zhang: Compute fac(2)
Task xiao wang: fac(2) = 2
Task xiao li: Compute fac(3)
Task xiao zhang: Compute fac(3)
Task xiao li: fac(3) = 6
Task xiao zhang: Compute fac(4)
Task xiao zhang: fac(4) = 24

这样应该可以理解为自动封装为一个task对象来处理了。

Python小知识 - asyncio之sleep和gather

Wed, 30 Jul 2025 10:40:48 +0800

asyncio 之 Sleep 阻塞休眠

coroutine asyncio.sleep(delay, result=None, *, loop=None)

阻塞指定的描述

如果指定了 result，则当协程完成时将其返回给调用者。

sleep() 总是会挂起当前任务，以允许其他任务运行。

Deprecated since version 3.8, will be removed in version 3.10: loop 形参。

以下协程示例运行 5 秒，每秒显示一次当前日期:


import asyncio
import datetime

async def display_date():
 loop = asyncio.get_running_loop()
 end_time = loop.time() + 5.0
 while True:
 print(datetime.datetime.now())
 if (loop.time() + 1.0) >= end_time:
 break

 await asyncio.sleep(1)

asyncio.run(display_date())

运行结果类似如下


$ python main.py
2020-08-13 22:26:19.414429
2020-08-13 22:26:20.417651
2020-08-13 22:26:21.418705
2020-08-13 22:26:22.420557
2020-08-13 22:26:23.421803

asyncio 之 Gather 并发运行任务

awaitable asyncio.gather(*aws, loop=None, return_exceptions=False)¶

并发运行 aws 序列中的可等待对象。

如果 aws 中的某个可等待对象为协程，它将自动作为一个任务加入日程。

如果所有可等待对象都成功完成，结果将是一个由所有返回值聚合而成的列表。结果值的顺序与 aws 中可等待对象的顺序一致。

如果 return_exceptions 为 False (默认)，所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象不会被取消并将继续运行。

如果 return_exceptions 为 True，异常会和成功的结果一样处理，并聚合至结果列表。

如果 gather() 被取消，所有被提交 (尚未完成) 的可等待对象也会被取消。

如果 aws 序列中的任一 Task 或 Future 对象被取消，它将被当作引发了 CancelledError 一样处理 – 在此情况下 gather() 调用不会被取消。这是为了防止一个已提交的 Task/Future 被取消导致其他 Tasks/Future 也被取消。

Deprecated since version 3.8, will be removed in version 3.10: loop 形参。

简单应用实例


import asyncio

async def factorial(name, number):
 f = 1
 for i in range(2, number + 1):
 print(f"Task {name}: Compure factorial({i})")
 await asyncio.sleep(1)
 f *= i
 print(f"Task {name}: factorial({number}) = {f}")

async def main():
 await asyncio.gather(factorial("X", 2), factorial("Y", 3),
 factorial("Z", 4))

asyncio.run(main())

运行结果类似如下


$ python main.py
Task X: Compure factorial(2)
Task Y: Compure factorial(2)
Task Z: Compure factorial(2)
Task X: factorial(2) = 2
Task Y: Compure factorial(3)
Task Z: Compure factorial(3)
Task Y: factorial(3) = 6
Task Z: Compure factorial(4)
Task Z: factorial(4) = 24

Python 3 小知识 - asyncio writable

Wed, 30 Jul 2025 10:40:45 +0800

在asyncio 中什么是 writable

在asyncio 中 writable 一般指的是 writable object

如果一个对象在await语句中使用，那么TA就是 writable object ，叫做可等待对象

在许多 asyncio API中，许多都被设计为 writable object

writable object 分为三种主要类型：Coroutines、Tasks和Futures

Coroutines

Coroutines 属于 writable object，因此可以在其他Coroutines中被等待:

比如如下代码


import asyncio

async def num():
 return 50

async def main():
 print(num())

 print(await num())

asyncio.run(main())

执行后的结果如下


$ python main.py
main.py:29: RuntimeWarning: coroutine 'num' was never awaited
 num()
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
50

Tasks

Tasks 被用来设置日程以便并发执行Coroutines

当一个Coroutines通过 asyncio.create_task() 等函数被打包为一个任务，该Coroutines将自动排入日程准备立即运行:

下面看如下实例代码


import asyncio

async def num():
 return 50

async def main():

 task = asyncio.create_task(num())

 print(await task)

asyncio.run(main())

执行后的结果如下


$ python main.py
50

Futures

Future 是一种特殊的低层级可等待对象，表示一个异步操作的最终结果。

当一个 Future 对象被等待，这意味着协程将保持等待直到该 Future 对象在其他地方操作完毕。

在 asyncio 中需要 Future 对象以便允许通过 async/await 使用基于回调的代码。

通常情况下没有必要在应用层级的代码中创建 Future 对象。

Future 对象有时会由库和某些 asyncio API 暴露给用户，用作可等待对象:

Python小知识 - asyncio使用记录（1）

Wed, 30 Jul 2025 10:40:26 +0800

asyncio是什么，如何使用

官方介绍如下，熟读

asyncio is a library to write concurrent code using the async/await syntax.

asyncio is used as a foundation for multiple Python asynchronous frameworks that provide high-performance network and web-servers, database connection libraries, distributed task queues, etc.

asyncio is often a perfect fit for IO-bound and high-level structured network code.

asyncio provides a set of high-level APIs to:

run Python coroutines concurrently and have full control over their execution;

perform network IO and IPC;

control subprocesses;

distribute tasks via queues;

synchronize concurrent code;

Additionally, there are low-level APIs for library and framework developers to:

create and manage event loops, which provide asynchronous APIs for networking, running subprocesses, handling OS signals, etc;

implement efficient protocols using transports;

bridge callback-based libraries and code with async/await syntax.

简单的看下如何使用，建议使用 Python 3.7+


import asyncio

async def main():
 print("Print ..... 1")
 await asyncio.sleep(10)
 print("Print ..... 2")

asyncio.run(main())

运行下之后，可以发现，“Print ….. 1”输出之后要过10秒才会输出“Print ….. 2”

这个不是并发的吗，为什么，用起来却不是并发的

其实上面的代码只是展示了如何用asyncio的async/await语法

看下如何实现并发的操作

实现之前先看下我么要做的功能


import time
import asyncio

async def start_run(delay, name):
 await asyncio.sleep(delay)
 print('%s start run' % name)

async def main():
 print(f"started at {time.strftime('%X')}")

 await start_run(2, 'dog')
 await start_run(3, 'cat')

 print(f"finished at {time.strftime('%X')}")

asyncio.run(main())

运行后输出结果如下


started at 20:15:09
dog start run
cat start run
finished at 20:15:14

这里我们知道要如何运行了，下面我们来实现下如何并发


import time
import asyncio

async def start_run(delay, name):
 await asyncio.sleep(delay)
 print('%s start run' % name)

async def main():
 dog_run = asyncio.create_task(start_run(2, 'dog'))
 cat_run = asyncio.create_task(start_run(3, 'cat'))

 print(f"started at {time.strftime('%X')}")

 await dog_run
 await cat_run

 print(f"finished at {time.strftime('%X')}")

asyncio.run(main())

运行后输出结果如下


started at 20:19:18
dog start run
cat start run
finished at 20:19:23

提示：暂时别像下面这样操作


import time
import asyncio

async def start_run(delay, name):
 await asyncio.sleep(delay)
 print('%s start run' % name)

async def main():
 print(f"started at {time.strftime('%X')}")

 await asyncio.create_task(start_run(2, 'dog'))
 await asyncio.create_task(start_run(3, 'cat'))

 print(f"finished at {time.strftime('%X')}")

asyncio.run(main())

我实验了下，不会有效果，待查

AsyncIO on Dapeng Zhang

Python asyncio协程 - 简单等待（二）

Python asyncio协程 - 简单等待（一）

Python asyncio协程 - 超时

屏蔽取消

超时（Timeouts）

Python asyncio协程 - gather(5)

如果 aws 序列中的任一 Task 或 Future 对象 被取消，它将被当作引发了 CancelledError 一样处理 – 在此情况下 gather() 调用 不会 被取消。这是为了防止一个已提交的 Task/Future 被取消导致其他 Tasks/Future 也被取消。

Python asyncio协程 - gather(4)

如果 gather() 被取消，所有被提交 (尚未完成) 的可等待对象也会 被取消。

Python asyncio协程 - gather(3)

如果 return_exceptions 为 False (默认)，所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象 不会被取消 并将继续运行。

如果 return_exceptions 为 True，异常会和成功的结果一样处理，并聚合至结果列表。

Python asyncio协程 - gather(2)

如果所有可等待对象都成功完成，结果将是一个由所有返回值聚合而成的列表。结果值的顺序与 aws 中可等待对象的顺序一致。

Python asyncio协程 - gather(1)

如果 aws 中的某个可等待对象为协程，它将自动作为一个任务加入日程。

Python小知识 - asyncio之sleep和gather

Python 3 小知识 - asyncio writable

Coroutines

Tasks

Futures

Python小知识 - asyncio使用记录（1）

如果 aws 序列中的任一 Task 或 Future 对象被取消，它将被当作引发了 CancelledError 一样处理 – 在此情况下 gather() 调用不会被取消。这是为了防止一个已提交的 Task/Future 被取消导致其他 Tasks/Future 也被取消。

如果 gather() 被取消，所有被提交 (尚未完成) 的可等待对象也会被取消。

如果 return_exceptions 为 False (默认)，所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象不会被取消并将继续运行。