python | Python协程调度：asyncio事件循环

本文来源公众号“python”，仅用于学术分享，侵权删，干货满满。

原文链接：Python协程调度：asyncio事件循环

Python的异步编程模型为处理I/O密集型任务提供了高效的解决方案。在众多并发编程方法中，asyncio库以其简洁的语法和强大的功能脱颖而出。本文将深入探讨Python协程调度机制和asyncio事件循环的工作原理，帮助开发者更好地理解和应用异步编程技术。

协程与异步编程

协程是一种特殊的函数，它可以在执行过程中暂停并稍后恢复。与传统的多线程编程相比，协程提供了一种轻量级的并发方式，避免了线程切换的开销和复杂的锁机制。

Python中的协程通过async/await语法实现。async关键字用于定义协程函数，而await关键字用于暂停协程执行，等待另一个协程完成。这种结构使得可以编写非阻塞的代码，同时保持了代码的清晰和可读性。

async def fetch_data():
    print("开始获取数据...")
    await asyncio.sleep(2)  # 模拟I/O操作
    print("数据获取完成")
    return {"data": "结果"}

在上面的例子中，fetch_data是一个协程函数。当执行到await asyncio.sleep(2)时，函数会暂停执行，控制权会交还给事件循环，2秒后再恢复执行。

asyncio事件循环详解

事件循环是asyncio库的核心，它负责协调所有异步任务的执行。简单来说，事件循环维护着一个任务队列，不断地检查并执行队列中已准备好的任务，同时暂停等待外部事件的任务。

1、事件循环的基本结构

asyncio的事件循环基于非阻塞I/O多路复用机制（如select、epoll或kqueue），能够同时监听多个I/O事件。当事件触发时，对应的回调函数会被调用。

import asyncio

# 获取事件循环
loop = asyncio.get_event_loop()

# 定义协程
async def main():
    print("主协程开始执行")
    await asyncio.sleep(1)
    print("主协程执行完毕")

# 运行协程直到完成
loop.run_until_complete(main())

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

在Python 3.7及以上版本中，推荐使用asyncio.run()函数来简化事件循环的管理：

import asyncio

async def main():
    print("主协程开始执行")
    await asyncio.sleep(1)
    print("主协程执行完毕")

asyncio.run(main())

2、事件循环的工作流程

事件循环的工作流程大致如下：

1. 从任务队列中选择一个任务执行

2. 任务执行到await语句时，将控制权交还给事件循环

3. 事件循环选择下一个可执行的任务继续执行

4. 当某个被暂停的任务的等待条件满足时，将其标记为可执行

5. 循环上述过程，直到所有任务完成或循环被停止

以下是一个更具体的例子，展示了事件循环如何协调多个协程的执行：

import asyncio
import time

async def say_after(delay, message):
    await asyncio.sleep(delay)
    print(f"{time.strftime('%X')}: {message}")

async def main():
    print(f"{time.strftime('%X')}: 开始执行")
    
    # 这两个协程会并发执行
    await asyncio.gather(
        say_after(1, "任务1完成"),
        say_after(2, "任务2完成")
    )
    
    print(f"{time.strftime('%X')}: 执行完毕")

asyncio.run(main())

运行结果：

10:15:00: 开始执行
10:15:01: 任务1完成
10:15:02: 任务2完成
10:15:02: 执行完毕

这个例子显示了两个协程是如何并发执行的。尽管有两个asyncio.sleep调用总共等待了3秒，但整个程序只用了约2秒完成，因为两个等待操作是并发进行的。

协程调度机制

asyncio的协程调度机制是通过事件循环和任务队列实现的。当一个协程暂停执行（通过await）时，事件循环会标记该协程的状态并将其放入等待队列。当协程等待的条件满足时，事件循环会将其重新加入到可执行队列中。

1、Task对象

在asyncio中，Task对象是协程的高级抽象，它封装了协程的执行状态和上下文。通过asyncio.create_task()或loop.create_task()可以创建一个任务：

async def background_task():
    while True:
        print("执行后台任务...")
        await asyncio.sleep(1)

async def main():
    # 创建任务
    task = asyncio.create_task(background_task())
    
    # 执行其他操作
    await asyncio.sleep(3)
    
    # 取消任务
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print("后台任务已取消")

asyncio.run(main())

Task对象允许我们控制协程的生命周期，例如取消正在执行的协程或检查其完成状态。

2、协程的挂起与恢复

当协程执行到await语句时，它会被挂起，控制权返回给事件循环。事件循环会继续执行其他可运行的协程。当被等待的条件满足时（例如，I/O操作完成或指定的时间已过），事件循环会将协程恢复执行。

async def process_data(data):
    print(f"开始处理数据: {data}")
    await asyncio.sleep(1)  # 模拟耗时处理
    result = data * 2
    print(f"数据处理完成: {result}")
    return result

async def main():
    # 并发处理多组数据
    results = await asyncio.gather(
        process_data(1),
        process_data(2),
        process_data(3)
    )
    print(f"所有结果: {results}")

asyncio.run(main())

运行结果：

开始处理数据: 1
开始处理数据: 2
开始处理数据: 3
数据处理完成: 2
数据处理完成: 4
数据处理完成: 6
所有结果: [2, 4, 6]

在这个例子中，三个process_data协程并发执行，当它们都处于挂起状态时，事件循环会等待所有协程完成。

asyncio的高级特性

除了基本的协程调度功能外，asyncio还提供了许多高级特性，使异步编程更加强大和灵活。

1、Future对象

Future对象表示未来某个时刻会完成的操作结果。它类似于其他语言中的Promise或Deferred对象，用于实现回调式的异步编程：

async def set_future_result(future):
    await asyncio.sleep(1)
    future.set_result("操作完成")

async def main():
    # 创建Future对象
    future = asyncio.Future()
    
    # 创建一个任务来设置Future的结果
    asyncio.create_task(set_future_result(future))
    
    # 等待Future完成
    result = await future
    print(result)

asyncio.run(main())

2、事件循环的自定义

在某些特殊场景下，开发者可能需要自定义事件循环的行为，例如集成其他异步框架或实现特殊的调度策略：

import asyncio
from asyncio import events

class CustomEventLoop(asyncio.SelectorEventLoop):
    def __init__(self):
        super().__init__()
        self.execution_count = 0
    
    def run_until_complete(self, future):
        self.execution_count += 1
        print(f"开始执行任务，这是第{self.execution_count}次执行")
        result = super().run_until_complete(future)
        print("任务执行完毕")
        return result

# 使用自定义事件循环
loop = CustomEventLoop()
asyncio.set_event_loop(loop)

async def main():
    await asyncio.sleep(1)
    print("任务完成")

loop.run_until_complete(main())
loop.close()

3、超时控制

asyncio提供了便捷的超时控制机制，可以为协程设置执行时间限制：

async def slow_operation():
    await asyncio.sleep(3)
    return "操作完成"

async def main():
    try:
        # 设置2秒超时
        result = await asyncio.wait_for(slow_operation(), timeout=2)
        print(result)
    except asyncio.TimeoutError:
        print("操作超时")

asyncio.run(main())

这个例子中，slow_operation协程需要3秒才能完成，但我们设置了2秒的超时限制，因此会抛出TimeoutError异常。

实际应用示例

下面是一个更实际的例子，展示如何使用asyncio处理多个HTTP请求：

import asyncio
import aiohttp
import time

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def fetch_all(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

async def main():
    urls = [
        "https://api.github.com",
        "https://api.github.com/events",
        "https://api.github.com/repos/python/cpython"
    ]
    
    start_time = time.time()
    results = await fetch_all(urls)
    elapsed = time.time() - start_time
    
    print(f"获取了{len(results)}个URL的内容，总耗时: {elapsed:.2f}秒")
    for i, result in enumerate(results):
        print(f"URL {i+1}: 内容长度 {len(result)} 字符")

asyncio.run(main())

这个例子使用aiohttp库并发地获取多个URL的内容。由于请求是并发进行的，总耗时大约等于最慢的那个请求的时间，而不是所有请求时间的总和。

最佳实践与注意事项

在使用asyncio进行协程调度时，有一些最佳实践和注意事项需要了解：

1. 避免CPU密集型操作：asyncio适合I/O密集型任务，而不适合CPU密集型任务。对于CPU密集型操作，应考虑使用concurrent.futures.ProcessPoolExecutor。

2. 注意阻塞调用：在协程中避免使用阻塞调用（如time.sleep()），应使用对应的异步版本（如asyncio.sleep()）。

3. 合理使用并发限制：过多的并发任务可能会导致资源耗尽。可以使用信号量控制并发数量：

async def limited_concurrency():
    # 限制最多3个并发任务
    semaphore = asyncio.Semaphore(3)
    
    async def worker(i):
        async with semaphore:
            print(f"任务{i}开始执行")
            await asyncio.sleep(1)
            print(f"任务{i}执行完毕")
    
    # 创建10个任务
    tasks = [worker(i) for i in range(10)]
    await asyncio.gather(*tasks)

asyncio.run(limited_concurrency())

1. 正确处理异常：确保在协程中正确处理异常，避免未捕获的异常导致程序崩溃：

async def might_fail():
    # 可能失败的操作
    if random.random() > 0.5:
        raise ValueError("操作失败")
    return "操作成功"

async def safe_operation():
    try:
        result = await might_fail()
        return result
    except ValueError as e:
        print(f"捕获到异常: {e}")
        return None

总结

Python的asyncio库为异步编程提供了一套优雅而强大的解决方案，核心在于其事件循环和协程调度机制。通过事件循环，asyncio能够协调多个协程的执行，实现非阻塞的并发操作，特别适合处理I/O密集型任务。async/await语法使异步代码的编写变得直观且易于维护，协程可以在执行过程中暂停并让出控制权，等待I/O操作完成后再恢复执行。

asyncio不仅提供了基本的协程运行机制，还包含丰富的工具集，如Task对象、Future、超时控制等高级特性，同时拥有庞大的第三方库生态系统支持。理解事件循环的工作原理和协程的调度机制，是编写高效异步程序的基础，可以帮助开发者充分利用Python的异步编程能力，构建响应迅速、资源利用率高的应用程序。

THE END !

文章结束，感谢阅读。您的点赞，收藏，评论是我继续更新的动力。大家有推荐的公众号可以评论区留言，共同学习，一起进步。