Python异步编程：TaskGroup与gather的对比与实践

1. 从混乱到秩序：理解结构化并发需求

在Python异步编程中，我们经常需要同时管理多个协程任务。传统做法是使用asyncio.gather()，但这种方式存在几个显著问题：

• 错误处理不透明：当多个任务中有一个失败时，其他任务会继续运行，直到所有任务完成才会抛出异常
• 取消操作不彻底：取消一个任务不会自动取消其他关联任务
• 资源管理困难：无法确保所有任务都能正确清理资源

python复制# 传统gather用法示例
async def fetch_data():
    task1 = asyncio.create_task(query_database())
    task2 = asyncio.create_task(fetch_api())
    results = await asyncio.gather(task1, task2, return_exceptions=True)
    # 需要手动检查每个结果是否异常

2. TaskGroup的核心机制解析

Python 3.11引入的asyncio.TaskGroup提供了更安全的并发管理模式：

2.1 上下文管理器协议

TaskGroup通过async with语法确保所有任务在退出代码块前完成：

python复制async with asyncio.TaskGroup() as tg:
    task1 = tg.create_task(coro1())
    task2 = tg.create_task(coro2())
# 此处所有任务保证已完成

2.2 错误传播机制

当任一子任务抛出异常时：

1. 立即取消所有其他未完成任务
2. 等待所有任务终止
3. 将异常包装在ExceptionGroup中抛出

python复制try:
    async with asyncio.TaskGroup() as tg:
        tg.create_task(failing_task())
        tg.create_task(long_running_task())
except* Exception as eg:
    # 处理异常组

2.3 取消语义

与普通任务取消不同，TaskGroup实现了结构化取消：

• 内部使用uncancel()机制确保取消操作原子性
• 取消计数精确管理，避免过早终止
• 支持嵌套取消场景

3. 实战对比：gather vs TaskGroup

3.1 基础用法对比

3.2 性能考量

虽然TaskGroup有更多安全保证，但在极端性能场景下：

• TaskGroup创建任务开销比gather高约15%
• 对于1000+任务的批处理，考虑混合模式：

python复制async def process_batch(batch):
    async with TaskGroup() as tg:
        for item in batch:
            tg.create_task(process_item(item))

async def main():
    batches = split_to_batches(large_dataset, 100)
    await asyncio.gather(*[process_batch(b) for b in batches])

4. 高级模式与最佳实践

4.1 嵌套任务组

TaskGroup支持多层嵌套，形成任务树结构：

python复制async def worker():
    async with TaskGroup() as tg:
        tg.create_task(subtask1())
        tg.create_task(subtask2())

async def main():
    async with TaskGroup() as root_tg:
        root_tg.create_task(worker())
        root_tg.create_task(other_worker())

4.2 资源清理模式

结合try/finally确保资源释放：

python复制async def db_operation():
    conn = await connect_db()
    try:
        async with TaskGroup() as tg:
            tg.create_task(update_record(conn))
            tg.create_task(log_operation(conn))
    finally:
        await conn.close()  # 确保无论成功失败都执行

4.3 超时控制

与asyncio.timeout配合使用：

python复制async def critical_section():
    try:
        async with asyncio.timeout(5), TaskGroup() as tg:
            tg.create_task(action1())
            tg.create_task(action2())
    except TimeoutError:
        # 自动取消所有子任务
        await emergency_cleanup()

5. 调试与问题排查

5.1 常见陷阱

1. 过早退出问题：

   python复制async def buggy_code():
       async with TaskGroup() as tg:
           tg.create_task(coro1())
           return  # 错误！会跳过等待
   

2. 错误处理不足：

   python复制async with TaskGroup() as tg:
       tg.create_task(may_fail())
   # 必须处理ExceptionGroup
   

5.2 调试技巧

1. 使用任务命名：

   python复制tg.create_task(coro(), name="query-api")
   

2. 获取活动任务信息：

   python复制def debug_tasks():
       for t in asyncio.all_tasks():
           print(f"{t.get_name()}: {t.get_coro()}")
   

6. 迁移指南：从gather到TaskGroup

6.1 简单转换

原始代码：

python复制results = await asyncio.gather(task1, task2, return_exceptions=True)

转换后：

python复制async with TaskGroup() as tg:
    t1 = tg.create_task(task1)
    t2 = tg.create_task(task2)
results = [t1.result(), t2.result()]  # 如有异常会提前抛出

6.2 复杂场景处理

对于需要部分成功结果的场景：

python复制success, errors = [], []
try:
    async with TaskGroup() as tg:
        t1 = tg.create_task(op1())
        t2 = tg.create_task(op2())
except* Exception as eg:
    for exc in eg.exceptions:
        errors.append(exc)
    # 收集已完成任务的结果
    for t in [t for t in (t1, t2) if t.done() and not t.cancelled()]:
        success.append(t.result())

在实际项目中，我发现逐步迁移比全量替换更稳妥。可以先从关键路径开始使用TaskGroup，逐步替换边缘场景的gather调用。对于已有完善错误处理的代码，迁移时可以保留原有逻辑，仅在新功能中使用TaskGroup。