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

异步编程：一文看完其异步函数表

1 低层级 asyncio 索引

1.1 获取事情循环

1.2 事情循环办法集

1.3 传输

1.3.1 读取传输

1.3.2 写入传输

1.3.3 数据报传输

1.3.4 子进程传输

1.3.5 协议

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

1.3.7 缓冲流协议

1.3.8 数据报协议

1.3.9 子进程协议

事情循环战略

2 高层 API索引

2.1 使命

比如

2 行列集

2.1 子进程集

3 同步

小结

作者信息

异步编程：一文看完其异步函数表

1 低层级 asyncio 索引

1.1 获取事情循环

1.2 事情循环办法集

1.3 传输

1.3.1 读取传输

1.3.2 写入传输

1.3.3 数据报传输

1.3.4 子进程传输

1.3.5 协议

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

1.3.7 缓冲流协议

1.3.8 数据报协议

1.3.9 子进程协议

事情循环战略

2 高层 API索引

2.1 使命

比如

2 行列集

2.1 子进程集

3 同步

小结

相关文章

机器学习：lightgbm（实战：分类&&回归）

iOS基础学习-1-启动时间监控

Nginx重写功能（rewrite与location）

Swift-iPhone、iPad 强制横屏操作怎么玩？

作者信息