Python中的协程任务组管理与gather()、wait()方法的区别

知识点描述
在Python asyncio中，当需要同时运行多个协程任务时，我们通常使用asyncio.gather()和asyncio.wait()方法。虽然两者都能实现并发执行，但它们在设计目的、返回结果、异常处理和控制粒度等方面存在重要差异。理解这些区别对于编写高效的异步代码至关重要。

详细讲解

1. 基本概念介绍

首先，让我们了解两个方法的基本定义：

• asyncio.gather(*aws, return_exceptions=False)：并发运行多个awaitable对象，返回结果列表
• asyncio.wait(aws, timeout=None, return_when=ALL_COMPLETED)：等待多个awaitable对象完成，返回完成和未完成的任务集合

2. 参数结构差异

asyncio.gather()的参数特点：

• 接受多个awaitable对象作为位置参数
• 支持return_exceptions参数控制异常处理
• 示例：

import asyncio

async def task1():
    return "结果1"

async def task2():
    return "结果2"

# gather使用方式
results = await asyncio.gather(task1(), task2())

asyncio.wait()的参数特点：

• 接受一个awaitable对象集合（列表、集合等）
• 支持超时控制和完成条件设置
• 示例：

tasks = [task1(), task2()]
done, pending = await asyncio.wait(tasks)

3. 返回结果对比

gather()的返回结果：

• 直接返回所有任务的结果列表
• 结果顺序与传入任务的顺序保持一致
• 示例分析：

async def test_gather():
    async def task(i):
        await asyncio.sleep(1)
        return f"任务{i}"
    
    results = await asyncio.gather(task(1), task(2), task(3))
    print(results)  # 输出: ['任务1', '任务2', '任务3']
    # 结果顺序与传入顺序相同

wait()的返回结果：

• 返回两个集合：(done, pending)
• done包含已完成的任务对象，pending包含未完成的任务
• 需要手动从任务对象中获取结果：

async def test_wait():
    async def task(i):
        await asyncio.sleep(1)
        return f"任务{i}"
    
    tasks = [task(1), task(2), task(3)]
    done, pending = await asyncio.wait(tasks)
    
    results = []
    for task_obj in done:
        result = task_obj.result()  # 需要手动获取结果
        results.append(result)
    print(results)  # 顺序可能不固定

4. 异常处理机制

gather()的异常处理：

• 默认行为：遇到第一个异常立即抛出，其他任务继续执行但结果被丢弃
• return_exceptions=True时：异常作为正常结果返回，不会中断执行

async def test_gather_exception():
    async def success_task():
        return "成功"
    
    async def fail_task():
        raise ValueError("错误")
    
    # 默认行为：立即抛出异常
    try:
        await asyncio.gather(success_task(), fail_task())
    except ValueError as e:
        print(f"捕获异常: {e}")
    
    # 异常作为结果返回
    results = await asyncio.gather(
        success_task(), 
        fail_task(), 
        return_exceptions=True
    )
    print(results)  # ['成功', ValueError('错误')]

wait()的异常处理：

• 异常不会立即抛出，只有在调用task.result()时才会抛出
• 需要手动检查每个任务的异常：

async def test_wait_exception():
    async def fail_task():
        raise ValueError("错误")
    
    tasks = [fail_task()]
    done, pending = await asyncio.wait(tasks)
    
    for task in done:
        try:
            result = task.result()  # 这里才会抛出异常
        except Exception as e:
            print(f"任务异常: {e}")

5. 控制粒度比较

gather()的控制特点：

• 相对简单，适合"全部完成或全部取消"的场景
• 不支持部分任务完成时的中间处理

wait()的精细控制：

• 支持三种完成条件：
  • ALL_COMPLETED：所有任务完成（默认）
  • FIRST_COMPLETED：第一个任务完成时返回
  • FIRST_EXCEPTION：第一个任务抛出异常或全部完成时返回

async def test_wait_control():
    async def long_task():
        await asyncio.sleep(5)
        return "长时间任务"
    
    async def short_task():
        await asyncio.sleep(1)
        return "短时间任务"
    
    tasks = [long_task(), short_task()]
    
    # 第一个任务完成时立即返回
    done, pending = await asyncio.wait(
        tasks, 
        return_when=asyncio.FIRST_COMPLETED
    )
    
    print(f"已完成: {len(done)}")  # 1
    print(f"未完成: {len(pending)}")  # 1
    
    # 可以继续处理未完成的任务
    if pending:
        done_second, pending_second = await asyncio.wait(pending)

6. 实际应用场景

适合使用gather()的场景：

• 需要所有任务的结果，且关注结果顺序
• 希望简单的异常处理逻辑
• 任务间没有依赖关系

# 示例：并行获取多个API数据
async def fetch_multiple_apis():
    urls = ["api1", "api2", "api3"]
    results = await asyncio.gather(*[fetch_api(url) for url in urls])
    # 结果顺序与URL列表顺序对应

适合使用wait()的场景：

• 需要超时控制或部分完成时的处理
• 任务优先级不同，需要更细粒度的控制
• 需要处理任务取消或动态添加任务的情况

# 示例：带超时的任务执行
async def execute_with_timeout():
    tasks = [slow_operation(), another_operation()]
    
    try:
        done, pending = await asyncio.wait(tasks, timeout=2.0)
        
        # 处理已完成的任务
        for task in done:
            process_result(task.result())
        
        # 取消超时任务
        for task in pending:
            task.cancel()
    except asyncio.TimeoutError:
        print("操作超时")

7. 性能考虑

• gather()通常更高效，因为内部优化更好
• wait()提供更多控制，但可能有额外开销
• 对于大量任务，考虑使用asyncio.as_completed()进行流式处理

通过理解这些差异，你可以根据具体需求选择最合适的方法，编写出更高效、更健壮的异步代码。