Pythonasyncio异步编程详解

**Python asyncio 异步编程入门指南：提升并发性能的利器** 想让你的 Python 程序在单线程中实现高并发吗？asyncio 库正是为此而生！本文作为 asyncio 异步编程入门教程，将深入浅出地介绍其核心概念：事件循环、协程、任务和 Future。事件循环作为 asyncio 的核心，负责调度协程、管理任务并处理 I/O 事件，实现单线程并发。协程是异步函数，任务包装协程并跟踪状态，Future 则代表未来结果。同时，本文还将详细讲解 asyncio 中的异常处理技巧，包括 try-except 语句、gather 的 return_exceptions 参数以及 add_done_callback 方法，助你轻松掌握 asyncio，编写出高效、稳定的异步程序。

事件循环是asyncio核心，负责调度协程、管理任务和处理I/O事件。它通过注册任务、监听事件、调度执行、切换协程及完成任务来实现单线程并发。协程是异步函数，任务包装协程并跟踪状态，Future表示未来结果，Task是其子类。异常处理可通过try-except、gather的return_exceptions或add_done_callback实现。

asyncio 是 Python 用于编写并发代码的库，使用 async/await 语法。它主要解决的问题是在单线程中实现高并发，避免传统多线程带来的资源消耗和上下文切换开销。简单来说，它让你在一个线程里同时做很多事情，提高效率。

asyncio 异步编程入门教程

要理解 asyncio，可以把它想象成一个任务调度员，它负责在不同的任务之间切换，让程序看起来像是同时在执行多个任务。

asyncio 的核心概念包括：事件循环（Event Loop）、协程（Coroutine）、任务（Task）和 Future。

事件循环是什么，它如何管理异步任务？

事件循环是 asyncio 的核心。它像一个总调度室，负责监听事件、调度任务。你可以把它想象成一个无限循环，不断地检查是否有任务需要执行。

事件循环管理异步任务的方式大致如下：

1. 注册任务： 将协程包装成 Task 对象，并添加到事件循环中。
2. 监听事件： 事件循环会监听各种事件，比如网络 I/O 完成、定时器到期等。
3. 调度执行： 当事件发生时，事件循环会找到对应的 Task，恢复协程的执行。
4. 切换任务： 当协程遇到 await 关键字时，会暂停执行，将控制权交还给事件循环。事件循环会选择下一个可以执行的 Task 继续执行。
5. 完成任务： 当协程执行完毕后，Task 对象会标记为已完成，事件循环会移除该 Task。

一个简单的例子：

import asyncio

async def my_coroutine(delay):
    print(f"Coroutine sleeping for {delay} seconds...")
    await asyncio.sleep(delay)
    print(f"Coroutine finished after {delay} seconds.")
    return f"Result after {delay} seconds"

async def main():
    task1 = asyncio.create_task(my_coroutine(2))
    task2 = asyncio.create_task(my_coroutine(1))

    print("Waiting for tasks to complete...")
    result1 = await task1
    result2 = await task2

    print(f"Task 1 result: {result1}")
    print(f"Task 2 result: {result2}")

if __name__ == "__main__":
    asyncio.run(main())

这段代码创建了两个协程 my_coroutine，分别休眠 2 秒和 1 秒。asyncio.create_task 将协程包装成 Task 对象，并添加到事件循环中。await 关键字用于等待 Task 完成。asyncio.run(main()) 启动事件循环，并执行 main 协程。

协程、任务和 Future 有什么区别，它们在异步编程中扮演什么角色？

• 协程（Coroutine）： 协程是一种特殊的函数，可以使用 async 关键字定义。它可以在执行过程中暂停，并在稍后恢复执行。协程是异步编程的基本单元。
• 任务（Task）： 任务是协程的包装器。asyncio.create_task 函数可以将协程包装成 Task 对象，并添加到事件循环中。任务对象可以跟踪协程的状态，比如是否已完成、是否已取消等。
• Future： Future 代表一个尚未完成的计算结果。它可以被 await，当结果可用时，await 会返回结果。Task 实际上是 Future 的一个子类。

它们之间的关系是：协程定义了异步操作的逻辑，任务负责调度协程的执行，Future 用于获取协程的返回值。

用一个比喻来说，协程是菜谱，任务是厨师，Future 是餐盘。菜谱描述了如何做菜，厨师负责按照菜谱做菜，餐盘用于盛放做好的菜。

如何处理 asyncio 中的异常？

在 asyncio 中，异常处理与同步代码类似，可以使用 try...except 语句。但需要注意的是，如果在协程中发生未捕获的异常，会导致程序崩溃。

以下是一些处理 asyncio 异常的技巧：

1. 在协程内部捕获异常： 这是最常见的做法，可以在协程内部使用 try...except 语句捕获异常，并进行处理。

import asyncio

async def my_coroutine():
    try:
        await asyncio.sleep(1)
        raise ValueError("Something went wrong")
    except ValueError as e:
        print(f"Caught an error: {e}")

async def main():
    await my_coroutine()

if __name__ == "__main__":
    asyncio.run(main())

2. 使用 asyncio.gather 处理多个任务的异常： asyncio.gather 可以同时运行多个任务，并返回一个包含所有任务结果的列表。如果其中一个任务发生异常，asyncio.gather 会抛出该异常。可以使用 return_exceptions=True 参数来忽略异常，并将异常作为结果返回。

import asyncio

async def my_coroutine(i):
    await asyncio.sleep(i)
    if i == 2:
        raise ValueError(f"Error in coroutine {i}")
    return f"Result from coroutine {i}"

async def main():
    results = await asyncio.gather(
        my_coroutine(1),
        my_coroutine(2),
        my_coroutine(3),
        return_exceptions=True
    )

    for result in results:
        if isinstance(result, Exception):
            print(f"Caught an error: {result}")
        else:
            print(f"Result: {result}")

if __name__ == "__main__":
    asyncio.run(main())

3. 使用 Task.add_done_callback 注册回调函数： 可以使用 Task.add_done_callback 方法注册一个回调函数，在任务完成时执行。回调函数可以检查任务是否成功完成，并处理异常。

import asyncio

async def my_coroutine():
    await asyncio.sleep(1)
    raise ValueError("Something went wrong")

def callback(task):
    try:
        result = task.result()
        print(f"Task completed with result: {result}")
    except Exception as e:
        print(f"Task failed with error: {e}")

async def main():
    task = asyncio.create_task(my_coroutine())
    task.add_done_callback(callback)
    await asyncio.sleep(2) # Allow time for the task to complete

if __name__ == "__main__":
    asyncio.run(main())

理解并掌握这些概念，就能更好地使用 asyncio 进行异步编程，提高程序的并发性能。

今天关于《Pythonasyncio异步编程详解》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！