Python事件循环

运行和停止循环¶

loop.run_until_complete(future)¶

运行直到 future ( Future 的实例 ) 被完成。

如果参数是 coroutine object ，将被隐式调度为 asyncio.Task 来运行。

返回 Future 的结果 或者引发相关异常。

loop.run_forever()¶

运行事件循环直到 stop() 被调用。

如果 stop() 在调用 run_forever() 之前被调用，循环将轮询一次 I/O 选择器并设置超时为零，再运行所有已加入计划任务的回调来响应 I/O 事件（以及已加入计划任务的事件），然后退出。

如果 stop() 在 run_forever() 运行期间被调用，循环将运行当前批次的回调然后退出。 请注意在此情况下由回调加入计划任务的新回调将不会运行；它们将会在下次 run_forever() 或 run_until_complete() 被调用时运行。

loop.stop()¶

停止事件循环。

loop.is_running()¶

返回 True 如果事件循环当前正在运行。

loop.is_closed()¶

如果事件循环已经被关闭，返回 True 。

loop.close()¶

关闭事件循环。

当这个函数被调用的时候，循环必须处于非运行状态。pending状态的回调将被丢弃。

此方法清除所有的队列并立即关闭执行器，不会等待执行器完成。

这个方法是幂等的和不可逆的。事件循环关闭后，不应调用其他方法。

coroutine loop.shutdown_asyncgens()¶

安排所有当前打开的 asynchronous generator 对象通过 aclose() 调用来关闭。 在调用此方法后，如果有新的异步生成器被迭代事件循环将会发出警告。 这应当被用来可靠地完成所有已加入计划任务的异步生成器。

运行请注意，当使用 asyncio.run() 时，无需调用此函数。

示例:

python3 notranslate">

try:
loop.run_forever()
finally:
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()

3.6 新版功能.

调度回调¶

loop.call_soon(callback, *args, context=None)¶

安排在下一次事件循环的迭代中使用 args 参数调用 callback 。

回调按其注册顺序被调用。每个回调仅被调用一次。

可选键值类的参数 context 允许 callback 运行在一个指定的自定义 contextvars.Context 对象中。如果没有提供 context ，则使用当前上下文。

返回一个能用来取消回调的 asyncio.Handle 实例。

这个方法不是线程安全的。

loop.call_soon_threadsafe(callback, *args, context=None)¶

call_soon() 的线程安全变体。必须被用于安排 来自其他线程 的回调。

参见 concurrency and multithreading 部分的文档。

# will schedule "print("Hello", flush=True)"
loop.call_soon(
functools.partial(print,"Hello",flush=True))

调度延迟回调¶

事件循环提供安排调度函数在将来某个时刻调用的机制。事件循环使用单调时钟来跟踪时间。

loop.call_later(delay, callback, *args, context=None)¶

安排 callback 在给定的 delay 秒（可以是 int 或者 float）后被调用。

返回一个 asyncio.TimerHandle 实例，该实例能用于取消回调。

callback 只被调用一次。如果两个回调被安排在同样的时间点，执行顺序未限定。

可选的位置参数 args 在被调用的时候传递给 callback  。 如果你想把关键字参数传递给 callback ，请使用 functools.partial() 。

可选键值类的参数 context 允许 callback 运行在一个指定的自定义 contextvars.Context 对象中。如果没有提供 context ，则使用当前上下文。

在 3.7 版更改: 加入键值类形参 context。请参阅 PEP 567 查看更多细节。

在 3.7.1 版更改: 在Python 3.7.0 和更早版本的默认事件循环实现中，delay 不能超过一天。在Python3.7.1中已被修复。

loop.call_at(when, callback, *args, context=None)¶

安排 callback 在给定的绝对时间戳的 时间 （一个 int 或者 float）被调用，使用与 loop.time() 同样的时间参考。

本方法的行为和 call_later() 方法相同。

返回一个 asyncio.TimerHandle 实例，该实例能用于取消回调。

在 3.7 版更改: 加入键值类形参 context。请参阅 PEP 567 查看更多细节。

在 3.7.1 版更改: 在Python 3.7.0 和更早版本的默认事件循环实现中， when 与当前时间的差值不能超过一天。在 Python3.7.1中已被修复。

loop.time()¶

根据时间循环内部的单调时钟，返回当前时间， float 值。

创建 Futures 和 Tasks¶

loop.create_future()¶

创建一个附加到事件循环中的 asyncio.Future 对象。

这是在asyncio中创建Futures的首选方式。这让第三方事件循环可以提供Future 对象的替代实现(更好的性能或者功能)。

3.5.2 新版功能.

loop.create_task(coro)¶

安排一个 协程 的执行。返回一个 Task 对象。

第三方的事件循环可以使用它们自己的 Task 子类来满足互操作性。这种情况下结果类型是一个 Task 的子类。

loop.set_task_factory(factory)¶

设置一个 task 工厂 ， 被用于 loop.create_task() 。

如果 factory 为 None 则将设置默认的任务工厂。 在其他情况下，factory 必须为一个 可调用对象 且签名匹配 (loop,coro)，其中 loop 是对活动事件循环的引用，而 coro 是一个协程对象。 该可调用对象必须返回一个兼容 asyncio.Future 的对象。

loop.get_task_factory()¶

返回一个任务工厂，或者如果是使用默认值则返回 None。

打开网络连接¶

coroutine loop.create_connection(protocol_factory, host=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, local_addr=None, server_hostname=None, ssl_handshake_timeout=None)¶

打开一个流式传输连接，连接到由 host 和 port 指定的地址。

套接字族可以是 AF_INET 或 AF_INET6，具体取决于 host (或 family 参数，如果有提供的话)。

套接字类型将为 SOCK_STREAM。

protocol_factory 必须为一个返回 asyncio 协议 实现的可调用对象。

这个方法会尝试在后台创建连接。当创建成功，返回 (transport,protocol) 组合。

底层操作的大致的执行顺序是这样的：

1. 创建连接并为其创建一个 传输。

2. 不带参数地调用 protocol_factory 并预期返回一个 协议 实例。

3. 协议实例通过调用其 connection_made() 方法与传输进行配对。

4. 成功时返回一个 (transport,protocol) 元组。

被创建的传输对象是一个实现相关的双向流。

其他参数：

• ssl: 如果给定该参数且不为假值，则会创建一个 SSL/TLS 传输（默认创建一个纯 TCP 传输）。 如果 ssl 是一个 ssl.SSLContext 对象，则会使用此上下文来创建传输对象；如果 ssl 为 True，则会使用从 ssl.create_default_context() 返回的默认上下文。

  参见

  SSL/TLS security considerations

• server_hostname 设置或重载目标服务器的证书将要匹配的主机名。 应当只在 ssl 不为 None 时传入。 默认情况下会使用 host 参数的值。 如果 host 为空那就没有默认值，你必须为 server_hostname 传入一个值。 如果 server_hostname 为空字符串，则主机名匹配会被禁用（这是一个严重的安全风险，使得潜在的中间人攻击成为可能）。

• family, proto, flags 是可选的地址族、协议和标志，它们会被传递给 getaddrinfo() 来对 host 进行解析。如果要指定的话，这些都应该是来自于 socket 模块的对应常量。

• sock，如果指定的话，其应该是一个已经存在，并且已经处于连接状态的 socket.socket 对象，其会被传输对象使用。如果指定了 sock ，那么 host, port, family, proto, flags 和 local_addr 就都不应该被指定了。

• 如果给出 local_addr，它应当是一个用来在本地绑定套接字的 (local_host,local_port) 元组。 local_host 和 local_port 会使用 getaddrinfo() 来查找，这与 host 和 port 类似。

• ssl_handshake_timeout 是（用于 TLS 连接的）在放弃连接之前要等待 TLS 握手完成的秒数。 如果参数为 None 则使用 (默认的) 60.0。

3.7 新版功能: ssl_handshake_timeout 形参。

在 3.6 版更改: 套接字选项 TCP_NODELAY 默认已为所有 TCP 连接进行了设置。

在 3.5 版更改: ProactorEventLoop 类中添加 SSL/TLS 支持。

参见

open_connection() 函数是一个高层级的替代 API。 它返回一对 (StreamReader, StreamWriter)，可在 async/await 代码中直接使用。

coroutine loop.create_datagram_endpoint(protocol_factory, local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_address=None, reuse_port=None, allow_broadcast=None, sock=None)¶

注解

形参 reuse_address 已不再受支持，因为使用 SO_REUSEADDR 会对 UDP 造成显著的安全问题。 显式地传入 reuse_address=True 将会引发异常。

当具有不同 UID 的多个进程将套接字赋给具有 SO_REUSEADDR 的相同 UDP 套接字地址时，传入的数据包可能会在套接字间随机分配。

对于受支持的平台，reuse_port 可以被用作类似功能的替代。 通过 reuse_port 将改用 SO_REUSEPORT，它能够防止具有不同 UID 的进程将套接字赋给相同的套接字地址。

创建一个数据报连接。

套接字族可以是 AF_INET, AF_INET6 或 AF_UNIX，具体取决于 host (或 family 参数，如果有提供的话)。

socket类型将是 SOCK_DGRAM 。

protocol_factory 必须为一个返回 协议 实现的可调用对象。

成功时返回一个 (transport,protocol) 元组。

其他参数：

• local_addr，如果指定的话，就是一个 (local_host,local_port) 元组，用于在本地绑定套接字。 local_host 和 local_port 是使用 getaddrinfo() 来查找的。

• remote_addr，如果指定的话，就是一个 (remote_host,remote_port) 元组，用于同一个远程地址连接。remote_host 和 remote_port 是使用 getaddrinfo() 来查找的。

• family, proto, flags 是可选的地址族，协议和标志，其会被传递给 getaddrinfo() 来完成 host 的解析。如果要指定的话，这些都应该是来自于 socket 模块的对应常量。

• reuse_port 告知内核，只要在创建时都设置了这个旗标，就允许此端点绑定到其他现有端点所绑定的相同端口上。 这个选项在 Windows 和某些 Unix 上不受支持。 如果 SO_REUSEPORT 常量未定义则此功能就是不受支持的。

• allow_broadcast 告知内核允许此端点向广播地址发送消息。

• sock 可选择通过指定此值用于使用一个预先存在的，已经处于连接状态的 socket.socket 对象，并将其提供给此传输对象使用。如果指定了这个值， local_addr 和 remote_addr 就应该被忽略 (必须为 None)。

本方法不支持Windows。Windows下，请使用 ProactorEventLoop 。

参见 UDP echo 客户端协议 和 UDP echo 服务端协议 的例子。

在 3.4.4 版更改: 添加了 family, proto, flags, reuse_address, reuse_port, allow_broadcast 和 sock 等参数。

在 3.7.6 版更改: 出于安全考虑，reuse_address 形参已不再受支持。

coroutine loop.create_unix_connection(protocol_factory, path=None, *, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None)¶

创建Unix 连接

套接字族将为 AF_UNIX；套接字类型将为 SOCK_STREAM。

成功时返回一个 (transport,protocol) 元组。

path 是所要求的 Unix 域套接字的名字，除非指定了 sock 形参。 抽象的 Unix 套接字, str, bytes 和 Path 路径都是受支持的。

请查看 loop.create_connection() 方法的文档了解有关此方法的参数的信息。

可用性: Unix。

3.7 新版功能: ssl_handshake_timeout 形参。

在 3.7 版更改: path 形参现在可以是 path-like object 对象。

创建网络服务¶

coroutine loop.create_server(protocol_factory, host=None, port=None, *, family=socket.AF_UNSPEC, flags=socket.AI_PASSIVE, sock=None, backlog=100, ssl=None, reuse_address=None, reuse_port=None, ssl_handshake_timeout=None, start_serving=True)¶

创建TCP服务 (socket 类型 SOCK_STREAM ) 监听 host 地址的 port 端口。

返回一个 Server 对象。

参数：

• protocol_factory 必须为一个返回 协议 实现的可调用对象。

• host 形参可被设为几种类型，它确定了服务器所应监听的位置:

  • 如果 host 是一个字符串，则 TCP 服务器会被绑定到 host 所指明的单一网络接口。

  • 如果 host 是一个字符串序列，则 TCP 服务器会被绑定到序列所指明的所有网络接口。

  • 如果 host 是一个空字符串或 None，则会应用所有接口并将返回包含多个套接字的列表（通常是一个 IPv4 的加一个 IPv6 的）。

• family 可被设为 socket.AF_INET 或 AF_INET6 以强制此套接字使用 IPv4 或 IPv6。 如果未设定，则 family 将通过主机名称来确定 (默认为 AF_UNSPEC)。

• flags 是用于 getaddrinfo() 的位掩码。

• 可以选择指定 sock 以便使用预先存在的套接字对象。 如果指定了此参数，则不可再指定 host 和 port。

• backlog 是传递给 listen() 的最大排队连接的数量（默认为100）。

• ssl 可被设置为一个 SSLContext 实例以在所接受的连接上启用 TLS。

• reuse_address 告知内核要重用一个处于 TIME_WAIT 状态的本地套接字，而不是等待其自然超时失效。 如果未指定此参数则在 Unix 上将自动设置为 True。

• reuse_port 告知内核，只要在创建的时候都设置了这个标志，就允许此端点绑定到其它端点列表所绑定的同样的端口上。这个选项在 Windows 上是不支持的。

• ssl_handshake_timeout 是（用于 TLS 服务器的）在放弃连接之前要等待 TLS 握手完成的秒数。 如果参数为 (默认值) None 则为 60.0 秒。

• start_serving 设置成 True (默认值) 会导致创建server并立即开始接受连接。设置成 False ，用户需要等待 Server.start_serving() 或者 Server.serve_forever() 以使server开始接受连接。

3.7 新版功能: 增加了 ssl_handshake_timeout 和 start_serving 形参。

在 3.6 版更改: 套接字选项 TCP_NODELAY 默认已为所有 TCP 连接进行了设置。

在 3.5 版更改: ProactorEventLoop 类中添加 SSL/TLS 支持。

在 3.5.1 版更改: host 形参可以是一个字符串的序列。

参见

start_server() 函数是一个高层级的替代 API，它返回一对 StreamReader 和 StreamWriter，可在 async/await 代码中使用。

coroutine loop.create_unix_server(protocol_factory, path=None, *, sock=None, backlog=100, ssl=None, ssl_handshake_timeout=None, start_serving=True)¶

与 loop.create_server() 类似但是专用于 AF_UNIX 套接字族。

path 是必要的 Unix 域套接字名称，除非提供了 sock 参数。 抽象的 Unix 套接字, str, bytes 和 Path 路径都是受支持的。

请查看 loop.create_server() 方法的文档了解有关此方法的参数的信息。

可用性: Unix。

3.7 新版功能: The ssl_handshake_timeout and start_serving parameters.

在 3.7 版更改: path 形参现在可以是 Path 对象。

coroutine loop.connect_accepted_socket(protocol_factory, sock, *, ssl=None, ssl_handshake_timeout=None)¶

将已被接受的连接包装成一个传输/协议对。

此方法可被服务器用来接受 asyncio 以外的连接，但是使用 asyncio 来处理它们。

参数：

• protocol_factory 必须为一个返回 协议 实现的可调用对象。

• sock 是一个预先存在的套接字对象，它是由 socket.accept 返回的。

• ssl 可被设置为一个 SSLContext 以在接受的连接上启用 SSL。

• ssl_handshake_timeout 是(为一个SSL连接)在中止连接前，等待SSL握手完成的时间【单位秒】。如果为 None (缺省) 则是 60.0 秒。

返回一个 (transport,protocol) 对。

3.7 新版功能: ssl_handshake_timeout 形参。

3.5.3 新版功能.

传输文件¶

coroutine loop.sendfile(transport, file, offset=0, count=None, *, fallback=True)¶

将 file 通过 transport 发送。 返回所发送的字节总数。

如果可用的话，该方法将使用高性能的 os.sendfile()。

file 必须是个二进制模式打开的常规文件对象。

offset 指明从何处开始读取文件。 如果指定了 count，它是要传输的字节总数而不再一直发送文件直至抵达 EOF。 文件位置总是会被更新，即使此方法引发了错误，并可以使用 file.tell() 来获取实际发送的字节总数。

fallback 设为 True 会使得 asyncio 在平台不支持 sendfile 系统调用时手动读取并发送文件（例如 Windows 或 Unix 上的 SSL 套接字）。

如果系统不支持 sendfile 系统调用且 fallback 为 False 则会引发 SendfileNotAvailableError。

3.7 新版功能.

TLS 升级¶

coroutine loop.start_tls(transport, protocol, sslcontext, *, server_side=False, server_hostname=None, ssl_handshake_timeout=None)¶

将现有基于传输的连接升级到 TLS。

返回一个新的传输实例，其中 protocol 必须在 await 之后立即开始使用。 传给 start_tls 方法的 transport 实例应永远不会被再次使用。

参数：

• transport 和 protocol 实例的方法与 create_server() 和 create_connection() 所返回的类似。

• sslcontext ：一个已经配置好的 SSLContext 实例。

• 当服务端连接已升级时 (如 create_server() 所创建的对象) server_side 会传入 True。

• server_hostname ：设置或者覆盖目标服务器证书中相对应的主机名。

• ssl_handshake_timeout 是（用于 TLS 连接的）在放弃连接之前要等待 TLS 握手完成的秒数。 如果参数为 None 则使用 (默认的) 60.0。

3.7 新版功能.

监控文件描述符¶

loop.add_reader(fd, callback, *args)¶

开始监视 fd 文件描述符以获取读取的可用性，一旦 fd 可用于读取，使用指定的参数调用 callback 。

loop.remove_reader(fd)¶

停止对文件描述符 fd 读取可用性的监视。

loop.add_writer(fd, callback, *args)¶

开始监视 fd 文件描述符的写入可用性，一旦 fd 可用于写入，使用指定的参数调用 callback 。

使用 functools.partial()传递关键字参数 给 callback.

loop.remove_writer(fd)¶

停止对文件描述符 fd 的写入可用性监视。

另请查看 平台支持 一节了解以上方法的某些限制。

直接使用 socket 对象¶

通常，使用基于传输的 API 的协议实现，例如 loop.create_connection() 和 loop.create_server() 比直接使用套接字的实现更快。 但是，在某些应用场景下性能并不非常重要，直接使用 socket 对象会更方便。

coroutine loop.sock_recv(sock, nbytes)¶

从 sock 接收至多 nbytes。 socket.recv() 的异步版本。

返回接收到的数据【bytes对象类型】。

sock 必须是个非阻塞socket。

在 3.7 版更改: 虽然这个方法总是被记录为协程方法，但它在 Python 3.7 之前的发行版中会返回一个 Future。 从 Python 3.7 开始它则是一个 asyncdef 方法。

coroutine loop.sock_recv_into(sock, buf)¶

从 sock 接收数据放入 buf 缓冲区。 模仿了阻塞型的 socket.recv_into() 方法。

返回写入缓冲区的字节数。

sock 必须是个非阻塞socket。

3.7 新版功能.

coroutine loop.sock_sendall(sock, data)¶

将 data 发送到 sock 套接字。 socket.sendall() 的异步版本。

此方法会持续发送数据到套接字直至 data 中的所有数据发送完毕或是有错误发生。 当成功时会返回 None。 当发生错误时，会引发一个异常。 此外，没有办法能确定有多少数据或是否有数据被连接的接收方成功处理。

sock 必须是个非阻塞socket。

在 3.7 版更改: 虽然这个方法一直被标记为协程方法。但是，Python 3.7 之前，该方法返回 Future ，从Python 3.7 开始，这个方法是 asyncdef 方法。

coroutine loop.sock_connect(sock, address)¶

将 sock 连接到位于 address 的远程套接字。

socket.connect() 的异步版本。

sock 必须是个非阻塞socket。

在 3.5.2 版更改: address 不再需要被解析。 sock_connect 将尝试检查 address 是否已通过调用 socket.inet_pton() 被解析。 如果没有，则将使用 loop.getaddrinfo() 来解析 address。

参见

loop.create_connection() 和 asyncio.open_connection() 。

coroutine loop.sock_accept(sock)¶

接受一个连接。 模仿了阻塞型的 socket.accept() 方法。

此 scoket 必须绑定到一个地址上并且监听连接。返回值是一个 (conn,address) 对，其中 conn 是一个 新*的套接字对象，用于在此连接上收发数据，*address 是连接的另一端的套接字所绑定的地址。

sock 必须是个非阻塞socket。

在 3.7 版更改: 虽然这个方法一直被标记为协程方法。但是，Python 3.7 之前，该方法返回 Future ，从Python 3.7 开始，这个方法是 asyncdef 方法。

参见

loop.create_server() 和 start_server()。

coroutine loop.sock_sendfile(sock, file, offset=0, count=None, *, fallback=True)¶

在可能的情况下使用高性能的 os.sendfile 发送文件。 返回所发送的字节总数。

socket.sendfile() 的异步版本。

sock 必须为非阻塞型的 socket.SOCK_STREAMsocket。

file 必须是个用二进制方式打开的常规文件对象。

offset 指明从何处开始读取文件。 如果指定了 count，它是要传输的字节总数而不再一直发送文件直至抵达 EOF。 文件位置总是会被更新，即使此方法引发了错误，并可以使用 file.tell() 来获取实际发送的字节总数。

当 fallback 被设为 True 时，会使用 asyncio 在平台不支持 sendfile 系统调用时手动读取并发送文件（例如 Windows 或 Unix 上的 SSL 套接字）。

如果系统不支持 sendfile 并且 fallback 为 False ，引发 SendfileNotAvailableError 异常。

sock 必须是个非阻塞socket。

3.7 新版功能.

DNS¶

coroutine loop.getaddrinfo(host, port, *, family=0, type=0, proto=0, flags=0)¶

异步版的 socket.getaddrinfo() 。

coroutine loop.getnameinfo(sockaddr, flags=0)¶

异步版的 socket.getnameinfo() 。

使用管道¶

coroutine loop.connect_read_pipe(protocol_factory, pipe)¶

在事件循环中注册 pipe 的读取端。

protocol_factory 必须为一个返回 asyncio 协议 实现的可调用对象。

pipe 是个 类似文件型对象.

返回一对 (transport,protocol)，其中 transport 支持 ReadTransport 接口而 protocol 是由 protocol_factory 所实例化的对象。

使用 SelectorEventLoop 事件循环， pipe 被设置为非阻塞模式。

coroutine loop.connect_write_pipe(protocol_factory, pipe)¶

在事件循环中注册 pipe 的写入端。

protocol_factory 必须为一个返回 asyncio 协议 实现的可调用对象。

pipe 是个 类似文件型对象.

返回一对 (transport,protocol)，其中 transport 支持 WriteTransport 接口而 protocol 是由 protocol_factory 所实例化的对象。

使用 SelectorEventLoop 事件循环， pipe 被设置为非阻塞模式。

Unix 信号¶

loop.add_signal_handler(signum, callback, *args)¶

设置 callback 作为 signum 信号的处理程序。

此回调将与该事件循环中其他加入队列的回调和可运行协程一起由 loop 发起调用。 不同与使用 signal.signal() 注册的信号处理程序，使用此函数注册的回调可以与事件循环进行交互。

如果信号数字非法或者不可捕获，就抛出一个 ValueError 。如果建立处理器的过程中出现问题，会抛出一个 RuntimeError 。

使用 functools.partial()传递关键字参数 给 callback.

和 signal.signal() 一样，这个函数只能在主线程中调用。

loop.remove_signal_handler(sig)¶

移除 sig 信号的处理程序。

如果信号处理程序被移除则返回 True，否则如果给定信号未设置处理程序则返回 False。

可用性: Unix。

在线程或者进程池中执行代码。¶

awaitable loop.run_in_executor(executor, func, *args)¶

安排在指定的执行器中调用 func 。

The executor argument should be an concurrent.futures.Executor

instance. The default executor is used if executor is None.

示例:

importasyncio
importconcurrent.futures
defblocking_io():
# File operations (such as logging) can block the
# event loop: run them in a thread pool.
withopen('/dev/urandom','rb')asf:
returnf.read(100)
defcpu_bound():
# CPU-bound operations will block the event loop:
# in general it is preferable to run them in a
# process pool.
returnsum(i*iforiinrange(10**7))
asyncdefmain():
loop=asyncio.get_running_loop()
## Options:
# 1. Run in the default loop's executor:
result=awaitloop.run_in_executor(
None,blocking_io)
print('default thread pool',result)
# 2. Run in a custom thread pool:
withconcurrent.futures.ThreadPoolExecutor()aspool:
result=awaitloop.run_in_executor(
pool,blocking_io)
print('custom thread pool',result)
# 3. Run in a custom process pool:
withconcurrent.futures.ProcessPoolExecutor()aspool:
result=awaitloop.run_in_executor(
pool,cpu_bound)
print('custom process pool',result)
asyncio.run(main())

这个方法返回一个 asyncio.Future 对象。

使用 functools.partial()传递关键字参数 给 func 。

在 3.5.3 版更改: loop.run_in_executor() 不会再配置它所创建的线程池执行器的 max_workers，而是将其留给线程池执行器 (ThreadPoolExecutor) 来设置默认值。

loop.set_default_executor(executor)¶

将 executor 设为 run_in_executor() 所使用的默认执行器。 executor 应当是 ThreadPoolExecutor 的实例。

3.7 版后已移除: 使用不是Using an executor that is not an instance of ThreadPoolExecutor 实例的执行器的做法已被弃用并将在 Python 3.9 中引起错误。

executor 必须是个 concurrent.futures.ThreadPoolExecutor 的实例。

错误处理API¶

允许自定义事件循环中如何去处理异常。

loop.set_exception_handler(handler)¶

将 handler 设置为新的事件循环异常处理器。

如果 handler 为 None，将设置默认的异常处理程序。 在其他情况下，handler 必须是一个可调用对象且签名匹配 (loop,context)，其中 loop 是对活动事件循环的引用，而 context 是一个包含异常详情的 dict (请查看 call_exception_handler() 文档来获取关于上下文的更多信息)。

loop.get_exception_handler()¶

返回当前的异常处理器，如果没有设置异常处理器，则返回 None 。

3.5.2 新版功能.

loop.default_exception_handler(context)¶

默认的异常处理器。

此方法会在发生异常且未设置异常处理程序时被调用。 此方法也可以由想要具有不同于默认处理程序的行为的自定义异常处理程序来调用。

context 参数和 call_exception_handler() 中的同名参数完全相同。

loop.call_exception_handler(context)¶

调用当前事件循环的异常处理器。

context 是个包含下列键的 dict 对象(未来版本的Python可能会引入新键)：

• 'message': 错误消息；

• 'exception' （可选）: 异常对象；

• 'future' （可选）: asyncio.Future 实例；

• 'handle' （可选）: asyncio.Handle 实例；

• 'protocol' （可选）: Protocol 实例；

• 'transport' （可选）: Transport 实例；

• 'socket' （可选）： socket.socket 实例。

注解

此方法不应在子类化的事件循环中被重载。 对于自定义的异常处理，请使用 set_exception_handler() 方法。

开启调试模式¶

loop.get_debug()¶

获取事件循环调试模式设置（bool）。

如果环境变量 PYTHONASYNCIODEBUG 是一个非空字符串，就返回 True ，否则就返回 False 。

loop.set_debug(enabled: bool)¶

设置事件循环的调试模式。

在 3.7 版更改: The new -Xdev command line option can now also be used

to enable the debug mode.

运行子进程¶

本小节所描述的方法都是低层级的。 在常规 async/await 代码中请考虑改用高层级的 asyncio.create_subprocess_shell() 和 asyncio.create_subprocess_exec() 便捷函数。

coroutine loop.subprocess_exec(protocol_factory, *args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)¶

用 args 指定的一个或者多个字符串型参数创建一个子进程。

args 必须是个由下列形式的字符串组成的列表：

• str;

• 或者由 文件系统编码格式 编码的 bytes。

第一个字符串指定可执行程序，其余的字符串指定其参数。 所有字符串参数共同组成了程序的 argv。

此方法类似于调用标准库 subprocess.Popen 类，设置 shell=False 并将字符串列表作为第一个参数传入；但是，Popen 只接受一个单独的字符串列表参数，而 subprocess_exec 接受多个字符串参数。

protocol_factory 必须为一个返回 asyncio.SubprocessProtocol 类的子类的可调用对象。

其他参数：

• stdin: either a file-like object representing a pipe to be

  connected to the subprocess's standard input stream using

  connect_write_pipe(), or the

  subprocess.PIPE constant (default). By default a new

  pipe will be created and connected.

• stdout: either a file-like object representing the pipe to be

  connected to the subprocess's standard output stream using

  connect_read_pipe(), or the

  subprocess.PIPE constant (default). By default a new pipe

  will be created and connected.

• stderr: either a file-like object representing the pipe to be

  connected to the subprocess's standard error stream using

  connect_read_pipe(), or one of

  subprocess.PIPE (default) or subprocess.STDOUT

  constants.

  By default a new pipe will be created and connected. When

  subprocess.STDOUT is specified, the subprocess' standard

  error stream will be connected to the same pipe as the standard

  output stream.

• All other keyword arguments are passed to subprocess.Popen

  without interpretation, except for bufsize, universal_newlines

  and shell, which should not be specified at all.

其他参数的文档，请参阅 subprocess.Popen 类的构造函数。

返回一对 (transport,protocol)，其中 transport 来自 asyncio.SubprocessTransport 基类而 protocol 是由 protocol_factory 所实例化的对象。

coroutine loop.subprocess_shell(protocol_factory, cmd, *, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)¶

基于 cmd 创建一个子进程，该参数可以是一个 str 或者按 文件系统编码格式 编码得到的 bytes ，使用平台的 "shell" 语法。

这类似与用 shell=True 调用标准库的 subprocess.Popen 类。

protocol_factory 必须为一个返回 SubprocessProtocol 类的子类的可调用对象。

请参阅 subprocess_exec() 了解有关其余参数的详情。

返回一对 (transport,protocol)，其中 transport 来自 SubprocessTransport 基类而 protocol 是由 protocol_factory 所实例化的对象。

importasyncio
defhello_world(loop):
"""A callback to print 'Hello World' and stop the event loop"""
print('Hello World')
loop.stop()
loop=asyncio.get_event_loop()
# Schedule a call to hello_world()
loop.call_soon(hello_world,loop)
# Blocking call interrupted by loop.stop()
try:
loop.run_forever()
finally:
loop.close()

importasyncio
importdatetime
defdisplay_date(end_time,loop):
print(datetime.datetime.now())
if(loop.time()+1.0)<end_time:
loop.call_later(1,display_date,end_time,loop)
else:
loop.stop()
loop=asyncio.get_event_loop()
# Schedule the first call to display_date()
end_time=loop.time()+5.0
loop.call_soon(display_date,end_time,loop)
# Blocking call interrupted by loop.stop()
try:
loop.run_forever()
finally:
loop.close()

importasyncio
fromsocketimportsocketpair
# Create a pair of connected file descriptors
rsock,wsock=socketpair()
loop=asyncio.get_event_loop()
defreader():
data=rsock.recv(100)
print("Received:",data.decode())
# We are done: unregister the file descriptor
loop.remove_reader(rsock)
# Stop the event loop
loop.stop()
# Register the file descriptor for read event
loop.add_reader(rsock,reader)
# Simulate the reception of data from the network
loop.call_soon(wsock.send,'abc'.encode())
try:
# Run the event loop
loop.run_forever()
finally:
# We are done. Close sockets and the event loop.
rsock.close()
wsock.close()
loop.close()

importasyncio
importfunctools
importos
importsignal
defask_exit(signame,loop):
print("got signal %s: exit"%signame)
loop.stop()
asyncdefmain():
loop=asyncio.get_running_loop()
forsignamein{'SIGINT','SIGTERM'}:
loop.add_signal_handler(
getattr(signal,signame),
functools.partial(ask_exit,signame,loop))
awaitasyncio.sleep(3600)
print("Event loop running for 1 hour, press Ctrl+C to interrupt.")
print(f"pid {os.getpid()}: send SIGINT or SIGTERM to exit.")
asyncio.run(main())