1 低层级 asyncio 索引

低层级 API 索引
列出一切低层级的 asyncio API。

1.1 获取事情循环

获取当时运转的事情循环 首选 函数：

asyncio.get_running_loop()

获得一个事情循环实例(当时或经过战略)：

asyncio.get_event_loop()

经过当时战略将事情循环设置当时事情循环：

asyncio.set_event_loop()

创立一个新的事情循环：

asyncio.new_event_loop()

比如：

运用asyncio.get_running_loop()

1.2 事情循环办法集

• 查阅

事情循环办法 相关的首要文档段落 。生命周期

运转一个期程/使命/可等候目标直到完结：

loop.run_until_complete()

一向运转事情循环：

loop.run_forever()

中止事情循环：

loop.stop()

封闭事情循环：

loop.close()

回来 True ， 假如事情循环正在运转：

loop.is_running()

回来 True ，假如事情循环已经被封闭：

loop.is_closed()

封闭异步生成器：

await loop.shutdown_asyncgens()

• 调试：

敞开或禁用调试形式：

loop.set_debug()

获取当时测验形式：

loop.get_debug()

调度回调函数：

loop.call_soon()

尽快调用回调：

loop.call_soon_threadsafe()

办法线程安全的变体：

	loop.call_soon()

在给定时刻 之后 调用回调函数：

loop.call_later()

在 指定 时刻调用回调函数：

loop.call_at()

• 线程/进程池

在 concurrent.futures 履行器中运转一个独占CPU或其它堵塞函数：

await loop.run_in_executor()

设置 loop.run_in_executor() 默认履行器：

loop.set_default_executor()

• 使命与期程

创立一个 Future 目标：

loop.create_future()

将协程当作 Task 相同调度：

loop.create_task()

设置 loop.create_task() 运用的工厂，它将用来创立 Tasks：

loop.set_task_factory()

获取 loop.create_task() 运用的工厂，它用来创立 Tasks：

loop.get_task_factory()

异步版的 socket.getaddrinfo()：

await loop.getaddrinfo()

异步版的 socket.getnameinfo()：

await loop.getnameinfo()

• 网络和IPC

翻开一个TCP链接：

await loop.create_connection()

创立一个TCP服务：

await loop.create_server()

翻开一个Unix socket衔接：

await loop.create_unix_connection()

创立一个Unix socket服务：

await loop.create_unix_server()

将 socket 包装成 (transport, protocol) 对：

await loop.connect_accepted_socket()

翻开一个数据报(UDP)衔接：

await loop.create_datagram_endpoint()

经过传输通道发送一个文件：

await loop.sendfile()

将一个已树立的链接升级到TLS：

await loop.start_tls()

将管道读取端包装成 (transport, protocol) 对：

await loop.connect_read_pipe()

将管道写入端包装成 (transport, protocol) 对：

await loop.connect_write_pipe()

• 套接字

从 socket 接纳数据：

await loop.sock_recv()

从 socket 接纳数据到一个缓冲区中：

await loop.sock_recv_into()

发送数据到 socket ：

await loop.sock_sendall()

链接 await loop.sock_connect() ：

await loop.sock_connect()

接受一个 socket 链接：

await loop.sock_accept()

运用 socket 发送一个文件：

await loop.sock_sendfile()

开端对一个文件描述符的可读性的监视：

loop.add_reader()

中止对一个文件描述符的可读性的监视：

loop.remove_reader()

开端对一个文件描述符的可写性的监视：

loop.add_writer()

中止对一个文件描述符的可写性的监视：

loop.remove_writer()

• Unix信号

给 signal 增加一个处理回调函数：

loop.add_signal_handler()

删去 signal 的处理回调函数：

loop.remove_signal_handler()

• 子进程集

衍生一个子进程：

loop.subprocess_exec()

从终端指令衍生一个子进程：

loop.subprocess_shell()

• 错误处理

调用反常处理器：

loop.call_exception_handler()

设置一个新的反常处理器：

loop.set_exception_handler()

获取当时反常处理器：

loop.get_exception_handler()

默认反常处理器完成：

loop.default_exception_handler()

• 比如

  运用 asyncio.get_event_loop() 和 loop.run_forever().

  运用 loop.call_later().

  运用 loop.create_connection() 完成 echo客户端.

  运用 loop.create_connection() 去 链接socket.

  运用add_reader()监听FD(文件描述符)的读取事情.

  运用loop.add_signal_handler().

  运用loop.add_signal_handler()。

1.3 传输

一切传输都完成以下办法:

transport.close()

封闭传输。

transport.is_closing()

回来 True ，假如传输正在封闭或已经封闭。

transport.get_extra_info()

请求传输的相关信息。

transport.set_protocol()

设置一个新协议。

transport.get_protocol()

回来当时协议。

传输能够接纳数据(TCP和Unix链接，管道等)。它经过 loop.create_connection(), loop.create_unix_connection(), loop.connect_read_pipe() 等办法回来。

1.3.1 读取传输

回来 True ，假如传输正在接纳：

transport.is_reading()

暂停接纳：

transport.pause_reading()

持续接纳：

transport.resume_reading()

传输能够发送数据(TCP和Unix链接，管道等)。它经过 loop.create_connection(), loop.create_unix_connection(), loop.connect_write_pipe() 等办法回来。

1.3.2 写入传输

向传输写入数据：

transport.write()

向传输写入缓冲：

transport.write()

回来 True ，假如传输支撑发送 EOF：

transport.can_write_eof()

在冲洗已缓冲的数据后封闭传输和发送EOF：

transport.write_eof()

当即封闭传输：

transport.abort()

回来写入流操控的高位符号位和低位符号位：

transport.get_write_buffer_size()

设置新的写入流操控的高位符号位和低位符号位：

transport.set_write_buffer_limits()

由 loop.create_datagram_endpoint() 回来的传输:

1.3.3 数据报传输

发送数据到长途链接端：

transport.sendto()

当即封闭传输：

transport.abort()

基于子进程的底层笼统传输，它由 loop.subprocess_exec() 和 loop.subprocess_shell() 回来:

1.3.4 子进程传输

回来子进程的进程ID：

transport.get_pid()

回来请求通讯管道 (stdin, stdout, 或 stderr)的传输：

transport.get_pipe_transport()

回来子进程的回来代号：

transport.get_returncode()

杀死子进程：

transport.kill()

发送一个信号到子进程：

transport.send_signal()

中止子进程：

transport.terminate()

杀死子进程并封闭一切管道：

transport.close()

1.3.5 协议

协议类能够由下面 回调办法 完成：

衔接树立时被调用:

callback connection_made()

衔接丢失或封闭时将被调用:

callback connection_lost()

传输的缓冲区超越高位符号位时被调用:

callback pause_writing()

传输的缓冲区传送到低位符号位时被调用:

callback resume_writing()

1.3.6 流协议 (TCP, Unix 套接字, 管道)

接纳到数据时被调用:

callback data_received()

接纳到EOF时被调用:

callback eof_received()

1.3.7 缓冲流协议

调用后会分配新的接纳缓冲区:

callback get_buffer()

用接纳的数据更新缓冲区时被调用:

callback buffer_updated()

接纳到EOF时被调用:

callback eof_received()

1.3.8 数据报协议

接纳到数据报时被调用:

callback datagram_received()

前一个发送或接纳操作引发 OSError 时被调用:

callback error_received()

1.3.9 子进程协议

子进程向 stdout 或 stderr 管道写入数据时被调用:

callback pipe_data_received()

与子进程通讯的其中一个管道封闭时被调用:

callback pipe_connection_lost()

子进程退出时被调用:

callback process_exited()

事情循环战略

战略是改动 asyncio.get_event_loop() 这类函数行为的一个底层机制。更多细节能够查阅 战略部分。

拜访战略

asyncio.get_event_loop_policy()

回来当时进程域的战略。

asyncio.set_event_loop_policy()

设置一个新的进程域战略。

AbstractEventLoopPolicy

战略目标的基类。

2 高层 API索引

列举了一切能用于 async/wait 的高层级asyncio API 集。

2.1 使命

运转异步程序，创立Task目标，等候多件事运转超时的公共集。

run()

创立事情循环，运转一个协程，封闭事情循环。

create_task()

发动一个asyncio的Task目标。

await sleep()

休眠几秒。

await gather()

并发履行一切事情的调度和等候。

await wait_for()

有超时操控的运转。

await shield()

屏蔽撤销操作

await wait()

完结状况的监控器

current_task()

回来当时Task目标

all_tasks()

回来事情循环中一切的task目标。

Task

Task目标

to_thread()

在不同的 OS 线程中异步地运转一个函数。

run_coroutine_threadsafe()

从其他OS线程中调度一个协程。

for in as_completed()

用 for 循环监控完结状况。

比如

运用 asyncio.gather() 并行运转.
运用 asyncio.wait_for() 强制超时.

撤销协程.

	asyncio.sleep() 的用法.

请首要参阅 协程与使命文档.

2 行列集

行列集被用于多个异步Task目标的运转调度，完成衔接池以及发布/订阅形式。

先进先出行列

Queue

优先级行列:

  PriorityQueue

后进先出行列:

LifoQueue

运用 asyncio.Queue 在多个并发使命间分配工作量.

2.1 子进程集

用于生成子进程和运转shell指令的工具包。

创立一个子进程:

await create_subprocess_exec()

运转一个shell指令:

await create_subprocess_shell()

比如运用 它履行一个shell指令.
请参阅 子进程 APIs 相关文档.

3 同步

能被用于Task目标集的，类似线程的同步基元组件。

互斥锁：

Lock

事情目标：

Event

条件目标：

Condition

信号量：

Semaphore

有界的信号量：

BoundedSemaphore

小结

运用异步库的比如

asyncio.Event 的用法.

请参阅asyncio文档 synchronization primitives.

反常

asyncio.TimeoutError

类似 wait_for() 等函数在超时时分被引发。请注意 asyncio.TimeoutError 与内建反常 TimeoutError 无关。

asyncio.CancelledError

当一个Task目标被撤销的时分被引发。请参阅 Task.cancel()。
在撤销请求发生的运转代码中如何处理CancelledError反常.

请参阅完整的 asyncio 专用反常 列表.

本文代码比如：

	https://docs.python.org/zh-cn/3/library/asyncio-future.html#asyncio-example-future