Python异步编程怎么实现？asyncio入门教程

想知道Python异步编程怎么实现吗？本文为你提供了一份asyncio入门教程。Python异步编程的核心在于asyncio库，它利用协程和事件循环机制，在I/O等待时切换任务，避免进程阻塞，从而显著提升效率。通过async定义协程函数，await暂停协程，asyncio.create_task()调度任务，asyncio.gather()等待多个任务，asyncio.run()驱动异步流程，即可实现高效的并发处理，尤其适用于网络请求、数据库查询等I/O密集型任务。掌握asyncio，让你的Python程序更高效！

Python实现异步编程的核心是asyncio库，它通过协程和事件循环机制，在等待I/O操作时切换任务，避免阻塞进程，从而提升效率。1. 使用async定义协程函数，返回协程对象；2. 用await暂停协程，等待其他协程或可等待对象完成；3. 利用asyncio.create_task()将协程包装为任务并调度运行；4. 通过asyncio.gather()同时等待多个任务结果；5. 由asyncio.run()创建和管理事件循环驱动整个异步流程。这种方式适用于网络请求、数据库查询等I/O密集型任务，并发执行显著缩短总耗时。

Python实现异步编程的核心，就是利用内置的asyncio库。它通过协程（coroutine）和事件循环（event loop）机制，让程序在等待I/O操作时，能够切换到其他任务，而非阻塞整个进程，从而显著提升效率。这是一种非阻塞、单线程并发的模式，对于处理大量I/O密集型任务，如网络请求、数据库查询或文件读写，其性能优势非常明显。

解决方案

要开始使用asyncio，你需要理解几个核心概念：async、await、协程、任务和事件循环。

async关键字用来定义一个协程函数，它本身不会立即执行，而是返回一个协程对象。await关键字则用于暂停当前协程的执行，等待另一个协程或可等待对象（如Future、Task）完成。一旦await等待的对象完成并返回结果，当前协程会从暂停的地方继续执行。

让我们通过一个模拟网络请求的例子来看看它是如何工作的。想象一下，你需要同时从几个不同的服务器获取数据，每个服务器的响应时间都不一样。如果用传统的同步方式，你必须等一个服务器响应完，才能开始请求下一个，效率会很低。但有了asyncio，你可以同时发起所有请求，然后等待它们各自完成。

import asyncio
import time

async def fetch_data(delay: int, name: str) -> str:
    """
    模拟从一个服务器获取数据，耗时由delay决定。
    """
    print(f"[{name}] 开始获取数据，预计耗时 {delay} 秒...")
    # await asyncio.sleep() 是一个非阻塞的等待，它会让出控制权给事件循环
    await asyncio.sleep(delay)
    print(f"[{name}] 数据获取完成。")
    return f"数据来自 {name}"

async def main():
    """
    主协程，协调多个数据获取任务。
    """
    start_time = time.time()
    print("开始并发获取数据...")

    # 使用 asyncio.create_task() 将协程包装成任务，并立即调度它们运行
    task1 = asyncio.create_task(fetch_data(3, "服务器A"))
    task2 = asyncio.create_task(fetch_data(1, "数据库B"))
    task3 = asyncio.create_task(fetch_data(2, "API接口C"))

    # asyncio.gather() 用于同时等待多个任务完成，并收集它们的结果
    # 它的行为类似于同步编程中的 join，但它是非阻塞的
    results = await asyncio.gather(task1, task2, task3)

    print("\n所有任务完成，结果：", results)
    end_time = time.time()
    print(f"总耗时：{end_time - start_time:.2f} 秒")

# 使用 asyncio.run() 来运行主协程。
# 它是 asyncio 库的入口点，负责创建和管理事件循环。
if __name__ == "__main__":
    asyncio.run(main())

当你运行这段代码时，你会发现尽管“服务器A”需要3秒，但总的执行时间大约也就在3秒左右，而不是3 + 1 + 2 = 6秒。这是因为当fetch_data函数遇到await asyncio.sleep(delay)时，它会暂停自己，将控制权交还给事件循环。事件循环发现还有其他任务（task2和task3）可以运行，就会去执行它们。这种非阻塞的并发，就是asyncio的核心魔力。我个人觉得，当你第一次看到这样的输出，并且理解其背后的原理时，那种“哦，原来如此”的感觉是相当美妙的。

为什么我们需要异步编程？同步阻塞的痛点在哪里？

说实话，我们日常编写的很多程序，尤其是涉及到网络请求、文件读写、数据库操作这类I/O密集型任务时，默认都是同步阻塞的。这意味着当程序发起一个请求，比如向某个API发送数据，它就会在那里“傻傻地”等着，直到收到响应或者超时。在这漫长的等待过程中，CPU可能什么也没做，只是空闲着，而程序也无法处理其他任何事情。

想象一下一个餐厅的服务员，他一次只能服务一位顾客。他给顾客点完餐，就必须站在那里，一直等到厨房把菜做好，顾客吃完，他收完钱，才能去服务下一位。这效率可想而知。这就是同步阻塞的痛点：资源利用率低下，响应时间慢，尤其是在高并发场景下，性能会急剧下降。对于Web服务器、爬虫、实时数据处理等应用来说，这种阻塞是致命的。

虽然多线程或多进程也能实现并发，但它们各自有其弊端。比如Python的GIL（全局解释器锁）限制了多线程在CPU密集型任务上的并行能力，而且线程/进程的创建和切换本身就存在不小的开销，管理起来也更复杂，容易出现死锁、竞态条件等问题。异步编程则提供了一种轻量级的、单线程的并发解决方案，它通过在I/O等待时切换任务，避免了不必要的资源浪费，且没有GIL的限制（因为是单线程），大大简化了并发逻辑。

asyncio的核心概念：协程、事件循环与任务

深入理解asyncio，离不开对这三个核心概念的把握。它们是构建异步程序的基石，缺一不可。

协程（Coroutines） 协程是asyncio中最小的执行单元。它们是特殊的函数，通过async def定义。与普通函数不同，协程在执行过程中可以被暂停（通过await），并在稍后从暂停的地方恢复执行。它们不是操作系统线程，而是由Python解释器在用户空间进行调度。这意味着它们非常轻量级，创建和切换的开销远小于线程。协程是“协作式”的，它们必须主动通过await来让出控制权，如果一个协程内部有长时间运行的CPU密集型计算而没有await，那么整个事件循环就会被阻塞。

事件循环（Event Loop） 事件循环是asyncio的“心脏”，它是整个异步程序的调度器。你可以把它想象成一个永不停歇的while循环，它负责：

1. 监听事件： 比如网络连接是否建立，数据是否到达，定时器是否到期。
2. 调度任务： 当事件发生时，事件循环会唤醒等待该事件的协程，让它继续执行。
3. 管理协程： 它负责在协程之间切换，确保在I/O等待时，CPU不会空闲，而是去执行其他就绪的协程。 asyncio.run()就是负责创建并启动这个事件循环的函数。

任务（Tasks） 协程对象本身只是一个“蓝图”，它不会自动运行。要让协程被事件循环调度执行，你需要将它包装成一个Task对象。asyncio.create_task()就是用来做这件事的。一个Task可以看作是一个协程的“运行实例”，它被提交给事件循环，由事件循环来管理其生命周期。当你await一个任务时，你实际上是在等待这个任务所包装的协程执行完成。Task是asyncio实现并发的关键，因为它允许事件循环同时跟踪和管理多个正在运行的协程。

理解这三者之间的关系很重要：你用async def定义协程，然后用asyncio.create_task()把协程变成任务，最后由事件循环来调度这些任务的执行。它们共同协作，实现了非阻塞的并发。

处理异步编程中的常见陷阱与调试技巧

异步编程虽然强大，但初学者很容易踩到一些坑。我刚开始接触asyncio的时候，最头疼的就是那些看似简单却能彻底阻塞整个程序的“陷阱”。

1. 阻塞代码：异步编程最大的敌人 最常见的错误，也是最致命的，就是在async函数中调用了同步的阻塞函数，而没有将其包装成异步版本。比如，在协程中直接调用time.sleep()而不是asyncio.sleep()，或者使用requests.get()而不是aiohttp.ClientSession().get()。一旦发生这种情况，整个事件循环就会被卡住，所有其他异步任务都无法执行，直到那个阻塞调用完成。

如何避免和发现？

• 始终使用异步库： 当进行I/O操作时，确保你使用的是支持asyncio的库，如aiohttp代替requests，aiomysql代替`pymysql等。
• 使用asyncio.to_thread处理同步阻塞： 如果你确实需要在异步代码中调用一个同步的CPU密集型或I/O阻塞函数，可以使用await asyncio.to_thread(sync_func, *args)。这会将同步函数放到一个单独的线程中运行，从而不阻塞主事件循环。但这会引入线程开销，应谨慎使用。
• 开启调试模式： 运行asyncio.run(main(), debug=True)。这会在事件循环中启用调试模式，当有协程长时间阻塞时，会打印警告信息，帮助你定位问题。

2. 任务取消与异常处理 异步任务并非总是一帆风顺。你可能需要取消一个长时间运行的任务，或者处理任务执行过程中抛出的异常。

• 取消任务： 可以通过task.cancel()来请求取消一个任务。被取消的任务会抛出asyncio.CancelledError异常。在协程内部，你可以捕获这个异常来执行清理工作，或者决定是否真的停止。

  async def my_task():
      try:
          print("任务开始...")
          await asyncio.sleep(100) # 模拟长时间运行
      except asyncio.CancelledError:
          print("任务被取消了！进行清理...")
          raise # 重新抛出，让调用者知道任务被取消
      finally:
          print("任务结束清理完成。")

• 异常处理： 异步代码中的异常处理与同步代码类似，使用try...except。当使用asyncio.gather()时，如果其中一个任务抛出异常，gather默认会立即停止等待其他任务，并重新抛出第一个遇到的异常。如果你希望即使有任务失败也继续等待其他任务完成，可以使用return_exceptions=True参数。

  async def fail_task():
      await asyncio.sleep(1)
      raise ValueError("Oops, 我失败了！")
  
  async def run_multiple_with_errors():
      results = await asyncio.gather(
          fetch_data(1, "成功任务"),
          fail_task(),
          return_exceptions=True # 即使有异常也返回结果
      )
      print("所有任务（包括失败的）结果:", results)
      # 结果中会包含异常对象

3. 资源管理：async with 对于需要打开和关闭资源（如文件、网络连接）的异步操作，async with语句是你的好帮手。它确保资源在使用完毕后能够正确释放，即使在发生异常时也能保证。这和同步的with语句非常相似，只是它操作的是异步上下文管理器。

import aiohttp

async def fetch_url_content(url):
    # aiohttp.ClientSession 是一个异步上下文管理器
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main_resource():
    content = await fetch_url_content("https://www.example.com")
    print(f"URL内容片段：{content[:100]}...")

# asyncio.run(main_resource())

掌握这些，你的asyncio之旅会顺畅许多。异步编程确实需要一些思维模式的转变，但一旦你掌握了它的精髓，你会发现它能让你写出更高效、更响应迅速的Python程序。

本篇关于《Python异步编程怎么实现？asyncio入门教程》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！