Python的协程异步IO（asyncio）详解_python asyncio

最新推荐文章于 2024-06-07 19:00:32 发布

Tx1xQn9G4

最新推荐文章于 2024-06-07 19:00:32 发布

阅读量1.2k

点赞数 22

分类专栏：程序员文章标签： python 网络开发语言

本文链接：https://blog.csdn.net/Tx1xQn9G4/article/details/138033656

版权

程序员专栏收录该内容

377 篇文章 0 订阅

订阅专栏

协程和用户态线程非常接近，用户态线程之间的切换不需要陷入内核，但部分操作系统中用户态线程的切换需要内核态线程的辅助。

协程是编程语言（或者 lib）提供的特性（协程之间的切换方式与过程可以由编程人员确定），是用户态操作。协程适用于 IO 密集型的任务。常见提供原生协程支持的语言有：c++20、golang、python 等，其他语言以库的形式提供协程功能，比如 C++20 之前腾讯的 fiber 和 libco 等等。

1.2 分类

协程有两种，一种无栈协程，python中以 asyncio 为代表，一种有栈协程，python 中以 gevent 为代表，本文主要讲解 asyncio 线程。

	有栈线程	无栈线程	备注
例子：	lua thread python gevent	C# yield return C# async\await python asyncio	无
是否拥有单独的上下文：	是	否	上下文包括寄存器、栈帧
局部变量保存位置：	栈	堆	无栈协程的局部变量保存在堆上，比如generator的数据成员。
优点：	1. 每个协程有单独的上下文，可以在任意的嵌套函数中任何地方挂起此协程。 2. 不需要编译器做语法支持，通过汇编指令即可实现	1. 不需要为每个协程保存单独的上下文，内存占用低。 2. 切换成本低，性能更高。	无
缺点：	1. 需要提前分配一定大小的堆内存保存每个协程上下文，所以会出现内存浪费或者栈溢出。 2. 上下文拷贝和切换成本高，性能低于无栈协程。	1. 需要编译器提供语义支持，比如C# yield return语法糖。 2. 只能在这个生成器内挂起此协程，无法在嵌套函数中挂起此协程。 3. 关键字有一定传染性，异步代码必须都有对应的关键字。作为对比，有栈协程只需要做对应的函数调用。	无栈协程无法在嵌套函数中挂起此协程，有栈协程由于是通过保存和切换上下文包括寄存器和执行栈实现，可以在协程函数的嵌套函数内部yield这个协程并唤醒。

二、python的asyncio协程详解

2.1 介绍

asyncio 是用来编写并发代码的库，使用 async/await 语法。

asyncio 被用作多个提供高性能 Python 异步框架的基础，包括网络和网站服务，数据库连接库，分布式任务队列等等。

asyncio 往往是构建 IO 密集型和高层级结构化网络代码的最佳选择。

asyncio 提供一组高层级 API 用于:

并发地运行 Python 协程并对其执行过程实现完全控制;
执行网络 IO 和 IPC;
控制子进程;
通过队列实现分布式任务;
同步并发代码;
创建和管理事件循环，以提供异步 API 用于网络化, 运行子进程，处理 OS 信号等等;
使用 transports 实现高效率协议;
通过 async/await 语法桥接基于回调的库和代码。

2.2 asyncio 协程的使用（用的python3.8的语法）

asyncio 函数的源代码地址：https://github.com/python/cpython/tree/3.8/Lib/asyncio

1）协程通过 async/await 语法进行声明，是编写 asyncio 应用的推荐方式。

asyncio.run() 函数用来运行最高层级的入口点 “main()” 函数。

asyncio.sleep(delay, result=None, *, loop=None) 函数用来阻塞指定的秒数。

# coding=utf8

import sys
import asyncio

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

asyncio.run(main())

2）事件循环函数（包括循环的创建、运行和停止）

asyncio.get_running_loop() 函数返回当前 OS 线程中正在运行的事件循环。
asyncio.get_event_loop() 函数获取当前事件循环。
asyncio.set_event_loop(loop) 函数将 loop 设置为当前 OS 线程的当前事件循环。
asyncio.new_event_loop() 函数创建一个新的事件循环。
loop.run_until_complete(future) 函数运行直到 future (Future 的实例) 被完成。
loop.run_forever() 函数运行事件循环直到 stop() 被调用。
loop.stop() 函数停止事件循环。
loop.is_running() 函数返回 True 如果事件循环当前正在运行。
loop.is_closed() 函数如果事件循环已经被关闭，返回 True 。
loop.close() 函数关闭事件循环。
loop.create_future() 函数创建一个附加到事件循环中的 asyncio.Future 对象。
loop.create_task(coro, *, name=None) 函数安排一个协程的执行。返回一个 Task 对象。
loop.set_task_factory(factory) 函数设置一个 task 工厂，被用于 loop.create_task() 。
loop.get_task_factory() 函数返回一个任务工厂，或者如果是使用默认值则返回 None。

示例1：

# coding=utf8

import sys
import asyncio

async def fun1():
    await asyncio.sleep(1)
    print('协程1')

async def fun2():
    await asyncio.sleep(1)
    print('协程2')

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait([fun1(), fun2()]))
loop.close()

示例2：

# coding=utf8

import sys
import asyncio
import time

# 一个对future进行赋值的函数
async def slow_operation(future, num):
    await asyncio.sleep(1)
    # 给future赋值
    future.set_result('Future'+ str(num) +' is done!')

def main():
    loop = asyncio.get_event_loop()
    # 创建一个future
    future1 = loop.create_future()
    # 使用ensure_future 创建Task
    asyncio.ensure_future(slow_operation(future1, 1))

    future2 = loop.create_future()
    asyncio.ensure_future(slow_operation(future2, 2))

    # gather Tasks，并通过run_uniti_complete来启动、终止loop
    loop.run_until_complete(asyncio.gather(future1, future2))

    print(future1.result())
    print(future2.result())

    loop.close()

if __name__ == "__main__":
    main()

3）调度回调和延迟回调

loop.call_soon(callback, *args, context=None) 函数安排 callback 在事件循环的下一次迭代时附带 args 参数被调用。回调按其注册顺序被调用。每个回调仅被调用一次。方法不是线程安全的。
loop.call_soon_threadsafe(callback, *args, context=None) 函数是 call_soon() 的线程安全变体。必须被用于安排来自其他线程的回调。
loop.call_later(delay, callback, *args, context=None) 函数安排 callback 在给定的 delay 秒（可以是 int 或者 float）后被调用。
loop.call_at(when, callback, *args, context=None) 函数安排 callback 在给定的绝对时间戳的时间（一个 int 或者 float）被调用，使用与 loop.time() 同样的时间参考。
loop.time() 函数根据时间循环内部的单调时钟，返回当前时间， float 值。

# coding=utf8

import sys
import asyncio
from threading import Thread
import time

def callback(arg, loop):
    print('回调函数arg={} 回调的时间time={}'.format(arg, loop.time()))

async def task(loop):
    now = loop.time()
    print('时钟时间:{}'.format(time.time()))
    print('时事件循环时间:{}'.format(loop.time()))
    print('注册回调函数')
    loop.call_at(now + 1, callback, 'call_at1', loop) # 等待1秒执行 call_at 函数
    loop.call_at(now + 2, callback, 'call_at2', loop)
    loop.call_later(3, callback, 'call_later1', loop) # 等待3秒执行 call_later 函数
    loop.call_later(4, callback, 'call_later2', loop)
    loop.call_soon(callback, 'call_soon', loop) # 立即执行执行 call_soon 函数
    await asyncio.sleep(4)

def main():
    event_loop = asyncio.get_event_loop()
    try:
        print('进入事件循环监听')
        event_loop.run_until_complete(task(event_loop))  # 将事件循环对象传入task函数中
    finally:
        print('关闭事件循环监听')
        event_loop.close()

if __name__ == "__main__":
    main()

4）socket连接和Streams函数

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, happy_eyeballs_delay=None, interleave=None) 函数打开一个流式传输连接，连接到由 host 和 port 指定的地址。
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 端口。
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.connect_accepted_socket(protocol_factory, sock, *, ssl=None, ssl_handshake_timeout=None) 函数将已被接受的连接包装成一个传输/协议对。
loop.sock_recv(sock, nbytes) 函数从 sock 接收至多 nbytes。 socket.recv() 的异步版本。
loop.sock_recv_into(sock, buf) 函数从 sock 接收数据放入 buf 缓冲区。模仿了阻塞型的 socket.recv_into() 方法。
loop.sock_sendall(sock, data) 函数将 data 发送到 sock 套接字。 socket.sendall() 的异步版本。
loop.sock_accept(sock) 函数接受一个连接。模仿了阻塞型的 socket.accept() 方法。
loop.sock_sendfile(sock, file, offset=0, count=None, *, fallback=True) 函数在可能的情况下使用高性能的 os.sendfile 发送文件。返回所发送的字节总数。
asyncio.open_connection(host=None, port=None, *, loop=None, limit=None, ssl=None, family=0, proto=0, flags=0, sock=None, local_addr=None, server_hostname=None, ssl_handshake_timeout=None) 函数建立网络连接并返回一对 (reader, writer) 对象。
asyncio.start_server(client_connected_cb, host=None, port=None, *, loop=None, limit=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) 函数启动套接字服务。
asyncio.open_unix_connection(path=None, *, loop=None, limit=None, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None) 函数建立一个 Unix 套接字连接并返回 (reader, writer) 这对返回值。与 open_connection() 相似，但是操作在 Unix 套接字上。
asyncio.start_unix_server(client_connected_cb, path=None, *, loop=None, limit=None, sock=None, backlog=100, ssl=None, ssl_handshake_timeout=None, start_serving=True) 函数启动一个Unix socket服务。与 start_server() 相似，但是是在 Unix 套接字上的操作。
asyncio.StreamReader 这个类表示一个提供api来从IO流中读取数据的读取器对象。

reader.read(n=-1) 函数读取 n 个byte. 如果没有设置 n , 则自动置为 -1 ，读至 EOF 并返回所有读取的byte。
reader.readline() 函数读取一行，其中“行”指的是以 \n 结尾的字节序列。如果读到EOF而没有找到 \n ，该方法返回部分读取的数据。如果读到EOF，且内部缓冲区为空，则返回一个空的 bytes 对象。
reader.readexactly(n) 函数精准读取 n 个 bytes，不能超过也不能少于。
reader.readuntil(separator=b’\n’) 函数从流中读取数据直至遇到分隔符成功后，数据和指定的separator将从内部缓冲区中删除(或者说被消费掉)。返回的数据将包括在末尾的指定separator。如果读取的数据量超过了配置的流限制，将引发 LimitOverrunError 异常，数据将留在内部缓冲区中并可以再次读取。如果在找到完整的separator之前到达EOF，则会引发 IncompleteReadError 异常，并重置内部缓冲区。 IncompleteReadError.partial 属性可能包含指定separator的一部分。
reader.at_eof() 函数如果缓冲区为空并且 feed_eof() 被调用，则返回 True 。

asyncio.StreamWriter 这个类表示一个写入器对象，该对象提供api以便于写数据至IO流中。

writer.write(data) 函数会尝试立即将 data 写入到下层的套接字。如果写入失败，数据会被排入内部写缓冲队列直到可以被发送。
writer.writelines(data) 函数会立即尝试将一个字节串列表（或任何可迭代对象）写入到下层的套接字。如果写入失败，数据会被排入内部写缓冲队列直到可以被发送。
writer.close() 函数会关闭流以及下层的套接字。
writer.can_write_eof() 函数如果下层的传输支持 write_eof() 方法则返回True，否则返回 False。
writer.write_eof() 函数在已缓冲的写入数据被刷新后关闭流的写入端。
writer.transport() 函数返回下层的 asyncio 传输。
writer.drain() 函数等待直到可以适当地恢复写入到流。
writer.is_closing() 函数如果流已被关闭或正在被关闭则返回 True。
writer.wait_closed() 函数等待直到流被关闭。

server 代码：

# coding=utf8

import asyncio
from asyncio import StreamReader, StreamWriter


async def echo(reader: StreamReader, writer: StreamWriter):
    data = await reader.read(1024)
    message = data.decode()
    addr = writer.get_extra_info('peername')

    print(f"Received {message} from {addr}")
    print(f"Send: {message}")

    writer.write(data)
    await writer.drain()

    writer.close()


async def main(host, port):
    server = await asyncio.start_server(echo, host, port)
    addr = server.sockets[0].getsockname()
    print(f'Serving on {addr}')
    async with server:
        await server.serve_forever()

asyncio.run(main("127.0.0.1", 9999))

client 代码：

# coding=utf8

import asyncio


async def tcp_echo_client(message):
    reader, writer = await asyncio.open_connection('127.0.0.1', 9999)
    print(f'Send to server: {message}')

    writer.write(message.encode())
    await writer.drain()

    data = await reader.read(1024)
    print(f'Received from server: {data.decode()}')

    writer.close()
    await writer.wait_closed()


if __name__ == '__main__':
    while True:
        send_msg = input("send: ")
        asyncio.run(tcp_echo_client(send_msg))

5）在线程或者进程池中执行代码

loop.run_in_executor(executor, func, *args) 函数安排在指定的执行器中调用 func 。

# coding=utf8

import asyncio
import concurrent.futures

def blocking_io():
    # File operations (such as logging) can block the
    # event loop: run them in a thread pool.
    with open('/dev/urandom', 'rb') as f:
        return f.read(100)

def cpu_bound():
    # CPU-bound operations will block the event loop:
    # in general it is preferable to run them in a
    # process pool.
    return sum(i * i for i in range(5))

async def main():
    loop = asyncio.get_running_loop()

    ## Options:

    # 1. Run in the default loop's executor:
    result = await loop.run_in_executor(
        None, blocking_io)
    print('default thread pool', result)
    print("\n")

    # 2. Run in a custom thread pool:
    with concurrent.futures.ThreadPoolExecutor() as pool:
        result = await loop.run_in_executor(
            pool, blocking_io)
        print('custom thread pool', result)
        print("\n")

    # 3. Run in a custom process pool:
    with concurrent.futures.ProcessPoolExecutor() as pool:
        result = await loop.run_in_executor(
            pool, cpu_bound)
        print('custom process pool', result)

asyncio.run(main())

6） **asyncio.create_task(coro, *, name=None) 函数**用来将一个协程打包为一个 Task 排入日程准备执行，并返回 Task 对象。

# coding=utf8

import sys
import asyncio
import time

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)

async def main():
    task1 = asyncio.create_task(
        say_after(1, 'hello'))

    task2 = asyncio.create_task(
        say_after(2, 'world'))

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

    # Wait until both tasks are completed (should take around 2 seconds.)
    await task1
    await task2

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

asyncio.run(main())

7）错误处理API

loop.set_exception_handler(handler) 函数将 handler 设置为新的事件循环异常处理器。
loop.get_exception_handler() 函数返回当前的异常处理器，如果没有设置异常处理器，则返回 None 。
loop.default_exception_handler(context) 函数默认的异常处理器。
loop.call_exception_handler(context) 函数调用当前事件循环的异常处理器。
loop.get_debug() 函数获取事件循环调试模式设置（bool）。
loop.set_debug(enabled: bool) 函数设置事件循环的调试模式。

# coding=utf8

import sys
import asyncio

def handle_exception(loop, context): 
    print('Error:', context['message']) 
 
async def my_task(): 
    await asyncio.sleep(1)
    print('task1')
 
loop = asyncio.get_event_loop() 
loop.set_exception_handler(handle_exception) 
loop.run_until_complete(my_task()) 
loop.close()

8）Future

asyncio.Future(*, loop=None) 函数是一个 Future 代表一个异步运算的最终结果。线程不安全。
asyncio.isfuture(obj) 函数用来判断如果 obj 为一个 asyncio.Future类的示例、 asyncio.Task 类的实例或者一个具有 _asyncio_future_blocking 属性的对象，返回 True。
asyncio.ensure_future(obj, *, loop=None) 函数创建新任务。
asyncio.wrap_future(future, *, loop=None) 函数将一个 concurrent.futures.Future 对象封装到 asyncio.Future 对象中。

Future 对象相关函数：

fut.result() 函数返回 Future 的结果。
fut.set_result(result) 函数将 Future 标记为完成并设置结果。
fut.set_exception(exception) 函数将 Future 标记为完成并设置一个异常。
fut.done() 函数如果 Future 为已完成则返回 True 。
fut.cancelled() 函数是如果 Future 已取消则返回 True
fut.add_done_callback(callback, *, context=None) 函数添加一个在 Future 完成时运行的回调函数。
fut.remove_done_callback(callback) 函数从回调列表中移除 callback 。
fut.cancel() 函数取消 Future 并调度回调函数。
fut.exception() 函数返回 Future 已设置的异常。
fut.get_loop() 函数返回 Future 对象已绑定的事件循环。

# coding=utf8

import sys
import asyncio
import time

# 定义一个协程
async def slow_operation(fut):
    await asyncio.sleep(1)
    fut.set_result(22)

def def_callback(fut):
    number = fut.result()
    print(number + 1)

def main():
    # 获得全局循环事件
    loop = asyncio.get_event_loop()

    # 实例化期物对象
    fut = asyncio.Future()
    asyncio.ensure_future(slow_operation(fut))

    # 执行回调函数
    fut.add_done_callback(def_callback)

    # loop 的 run_until_complete 会将 _run_until_complete_cb 添加到 future 的完成回调列表中。而 _run_until_complete_cb 中会执行 loop.stop() 方法
    loop.run_until_complete(fut)

    # 关闭事件循环对象
    loop.close()

if __name__ == "__main__":
    main()

9）**asyncio.gather(*aws, loop=None, return_exceptions=False) 函数用来并发运行** aws 序列中的可等待对象。如果 aws 中的某个可等待对象为协程，它将自动作为一个任务加入日程。

# coding=utf8

import sys
import asyncio

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

async def main():
    # Schedule three calls *concurrently*:
    await asyncio.gather(
        factorial("A", 2),
        factorial("B", 3),
        factorial("C", 4),
    )

asyncio.run(main())
 **自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

![img](https://img-blog.csdnimg.cn/img_convert/0b5154c5b1f6709467b22dc67b65302e.png)

![img](https://img-blog.csdnimg.cn/img_convert/3e810fc002afc28e9889b4f2b7c7e75d.png)

![img](https://img-blog.csdnimg.cn/img_convert/1a4233b98b853e86fcc9bc5d2fef7421.png)

![img](https://img-blog.csdnimg.cn/img_convert/79f55c21263c86ad9d792f2c47e9d8b5.png)

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）**

轻大家的负担。**

[外链图片转存中...(img-yk4zp9ss-1713681340857)]

[外链图片转存中...(img-559HTC65-1713681340858)]

[外链图片转存中...(img-k5Jx3YXY-1713681340859)]

[外链图片转存中...(img-AaOJX9S2-1713681340859)]

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）**

![](https://img-blog.csdnimg.cn/img_convert/3195a3cc5dda1861475df4e82f0f1057.jpeg)

Tx1xQn9G4

关注

22
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
Python的协程异步IO（asyncio）详解_python asyncio

asyncio 是用来编写并发代码的库，使用 async/await 语法。asyncio 被用作多个提供高性能 Python 异步框架的基础，包括网络和网站服务，数据库连接库，分布式任务队列等等。asyncio 往往是构建 IO 密集型和高层级结构化网络代码的最佳选择。并发地运行 Python 协程并对其执行过程实现完全控制;执行网络 IO 和 IPC;控制子进程;通过队列实现分布式任务;同步并发代码;
复制链接

扫一扫