Python 异步编程 asyncio简介及基本用法_Python

1、asyncio是什么

async io（异步输入输出）是一种编程模式，它允许程序在等待i/o操作（如文件读写、网络请求等）完成时继续执行其他任务。通过这种方式，可以更有效地利用cpu资源和提高程序的响应速度，尤其是在处理大量并发连接或长时间运行的任务时。

asyncio 是 python 的一个库，用于编写并发代码，使用协程、任务和 futures 来处理 i/o 密集型和高延迟操作

正常的发送请求，发送请求后会等待连接建立和服务器响应，这段时间内cpu是空闲的，也无法切换到其他任务

asyncio允许当执行的任务遇到io密集型任务时（如发送请求），cpu空闲，将cpu切换到其他任务上，做其他任务，等请求建立后，可以重新切换回来，继续进行操作

io密集型任务

io 密集型任务是指那些大部分时间都花费在输入/输出（i/o）操作上的任务。这些任务的特点是，cpu 的计算量相对较小，而等待 i/o 操作完成的时间较长。常见的 io 密集型任务包括文件读写、网络请求、数据库查询等。

例如连接网络，发起连接时需要cpu参与，等待连接过程是不需要cpu参与，这段时间，cpu可以空闲下来，进行其他操作，等待到连接建立成功后需要传输数据了cpu再进行操作

特征

长时间等待：大量时间花在等待外部设备或服务的响应上。
低 cpu 占用：cpu 在等待 i/o 操作完成时处于空闲状态，因为不需要进行复杂的计算。

2、怎么用

1、基本用法

import asyncio
# 定义一个异步函数
async def my_coroutine():
    print("开始任务")
    # 模拟一个耗时操作
    await asyncio.sleep(1)  # 等待1秒
    print("任务完成")
# 创建事件循环
loop = asyncio.get_event_loop()
# 运行异步函数直到完成
loop.run_until_complete(my_coroutine())
# 关闭事件循环
loop.close()

定义了一个名为my_coroutine的协程（coroutine），它会打印一条开始任务，然后暂停执行一段时间（模拟i/o操作），最后再打印任务完成。await关键字用于暂停协程的执行，直到等待的操作完成。asyncio.sleep是专门用来模拟异步等待的函数，在实际应用中，你可能会替换为真正的异步i/o操作，比如网络请求或文件操作。

如果你想要同时运行多个异步任务，你可以使用asyncio.gather或者asyncio.wait等函数来管理这些任务。

实际上这样显示不出协程的用途

但是如果有多个任务就可以了

import asyncio
# 定义一个异步函数
async def my_coroutine1():
    print("开始任务1")
    # 模拟一个耗时操作
    await asyncio.sleep(1)  # 等待1秒
    print("任务完成1")
async def my_coroutine2():
    print("开始任务2")
    # 模拟一个耗时操作
    await asyncio.sleep(1)  # 等待1秒
    print("任务完成2")
async def main():
    results =  await asyncio.gather(my_coroutine1(), my_coroutine2())
    print(results)
if __name__ == '__main__':
    asyncio.run(main())

2、关键字 async

定义：

async关键字用来声明一个函数为异步函数（即协程）。当一个函数被定义为异步时，它不会像普通函数那样立即执行其内部代码，而是返回一个协程对象。这个协程对象可以在事件循环中调度执行。

async def function_name(parameters):
    # 协程体

使用场景：

当你需要定义一个可能会进行长时间等待的函数（如网络请求、文件读写等），你可以使用async来标记该函数，表明它是一个异步操作，并且可以通过await来暂停它的执行直到某些条件满足。

await

定义：await关键字只能出现在由async定义的函数内部，用于暂停当前协程的执行，直到所等待的另一个协程或异步操作完成。await后面通常跟的是一个可等待对象（如另一个协程、future、task等）。

语法：

await expression

使用场景：

当你在一个异步函数内需要等待另一个异步操作的结果时，你可以使用await来暂停当前函数的执行，让出cpu资源给其他任务，直到等待的操作完成。

asyncio.run()：

这是运行顶层协程的主要方式，适用于python 3.7+版本。它会创建一个新的事件循环并运行传入的协程，直到协程完成。完成后，它会关闭事件循环并返回协程的结果。

asyncio.create_task()：

用于在事件循环中并发启动多个协程。它接受一个协程作为参数，并返回一个task对象，该对象代表了正在运行的任务。这有助于管理并发任务，比如同时发起多个网络请求。

import asyncio
async def task1():
    print("task 1 started")
    await asyncio.sleep(1)
    print("task 1 completed")
async def task2():
    print("task 2 started")
    await asyncio.sleep(2)
    print("task 2 completed")
async def main():
    # 创建任务但不等待它们
    task_1 = asyncio.create_task(task1())
    task_2 = asyncio.create_task(task2())
    # 执行其他代码...
    # 等待任务完成
    await task_1
    await task_2
# 运行主函数
asyncio.run(main())

asyncio.gather()：

如果想要并发地运行多个协程并且收集所有结果，可以使用gather。它可以接收多个协程作为参数，并返回一个包含所有协程返回值的列表。

import asyncio
async def task1():
    print("task 1 started")
    await asyncio.sleep(1)
    print("task 1 completed")
    return "result from task 1"
async def task2():
    print("task 2 started")
    await asyncio.sleep(2)
    print("task 2 completed")
    return "result from task 2"
async def main():
    # 使用 gather 同时运行多个任务
    results = await asyncio.gather(task1(), task2())
    print(results)
# 运行主函数
asyncio.run(main())

asyncio.wait() 可以用来等待一组协程中的任意数量完成。你可以指定不同的等待条件，如全部完成、任何一个完成等。

import asyncio
async def task1():
    print("task 1 started")
    await asyncio.sleep(1)
    print("task 1 completed")
async def task2():
    print("task 2 started")
    await asyncio.sleep(2)
    print("task 2 completed")
async def main():
    # 创建任务列表
    tasks = [task1(), task2()]
    # 等待所有任务完成
    done, pending = await asyncio.wait(tasks, return_when=asyncio.all_completed)
    for future in done:
        print(future.result())
# 运行主函数
asyncio.run(main())

如果你想按完成顺序处理结果，而不是按照任务创建的顺序，可以使用 asyncio.as_completed()。它返回一个迭代器，在每个协程完成后产生它的future对象。

import asyncio
async def task1():
    print("task 1 started")
    await asyncio.sleep(1)
    print("task 1 completed")
    return "result from task 1"
async def task2():
    print("task 2 started")
    await asyncio.sleep(2)
    print("task 2 completed")
    return "result from task 2"
async def main():
    # 创建任务列表
    tasks = [task1(), task2()]
    # 按完成顺序处理结果
    for future in asyncio.as_completed(tasks):
        result = await future
        print(result)
# 运行主函数
asyncio.run(main())