Python异步 vs 线程：何时使用asyncio

为什么并发在Python中很重要

你有一个从多个API获取数据的Python脚本。它能工作，但很慢——每个请求都要等待前一个完成。你听说过asyncio和线程，但该用哪个？选错模型可能导致代码要么不必要地复杂，要么慢得令人痛苦。

本指南将拨开迷雾。我们将比较Python的异步和线程模型，明确展示何时使用每种，并提供可适配到你自己项目的实用示例。

理解Python的并发格局

Python提供三种主要并发模型：

• 线程 – 单个进程内的多个执行线程，由操作系统管理。受全局解释器锁（GIL）限制，不适合CPU密集型工作。
• 异步 (asyncio) – 单线程事件循环，在await点之间切换任务。非常适合I/O密集型操作。
• 多进程 – 独立的进程，每个都有自己的Python解释器和内存空间。绕过GIL实现真正的并行。

GIL是一个互斥锁，防止多个线程同时执行Python字节码。这意味着线程不会加速CPU密集型任务，但它们确实有助于I/O密集型任务，因为GIL在I/O操作期间被释放。

何时使用asyncio

asyncio在程序大部分时间等待外部事件时表现出色：网络请求、文件I/O、数据库查询或定时器。因为它使用单线程，避免了线程创建和上下文切换的开销。事件循环能高效管理数千个并发连接。

在以下情况使用asyncio：

• 你正在构建处理大量同时连接的Web服务器或客户端（例如FastAPI、aiohttp）。
• 你的任务是I/O密集型且需要高并发（数百或数千个任务）。
• 你想对任务调度和取消进行细粒度控制。
• 你已经在使用异步框架或库。

这是一个并发获取多个URL的简单示例：

import asyncio
import aiohttp

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

async def main():
    urls = [
        'https://example.com',
        'https://example.org',
        'https://example.net',
    ]
    tasks = [fetch(url) for url in urls]
    results = await asyncio.gather(*tasks)
    print(f'Fetched {len(results)} pages')

asyncio.run(main())

何时使用线程

当你有阻塞式I/O操作且没有异步等价物，或者你正在处理不支持异步的遗留代码时，线程是合适的选择。对于少量任务，它们也更容易理解。

在以下情况使用线程：

• 你需要并行运行阻塞式I/O，例如读取多个文件或进行同步API调用。
• 你正在集成不支持异步的库。
• 你有中等数量的并发任务（几十个，而不是数千个）。
• 你想保持代码同步但仍重叠I/O。

使用concurrent.futures.ThreadPoolExecutor的示例：

from concurrent.futures import ThreadPoolExecutor
import requests

def fetch(url):
    response = requests.get(url)
    return response.text

urls = [
    'https://example.com',
    'https://example.org',
    'https://example.net',
]

with ThreadPoolExecutor(max_workers=10) as executor:
    results = list(executor.map(fetch, urls))

print(f'Fetched {len(results)} pages')

比较asyncio和线程

以下是并排比较，帮助你决定：

CPU密集型任务呢？

由于GIL，asyncio和线程都无法帮助你在Python中并行化CPU密集型工作。对于CPU密集型任务——如数值计算、图像处理或数据压缩——使用multiprocessing或concurrent.futures.ProcessPoolExecutor。

示例：

from concurrent.futures import ProcessPoolExecutor

def cpu_heavy(n):
    return sum(i * i for i in range(n))

if __name__ == '__main__':
    with ProcessPoolExecutor() as executor:
        results = list(executor.map(cpu_heavy, [10**6, 10**6, 10**6]))
    print(results)

最佳实践和陷阱

• 不要将阻塞调用与asyncio混合。 如果在异步任务中调用阻塞函数，它会阻塞整个事件循环。使用asyncio.to_thread()在线程池中运行阻塞代码。
• 限制线程池大小。 创建过多线程会导致上下文切换开销。使用ThreadPoolExecutor(max_workers=N)。
• 正确处理异常。 在asyncio中，任务中未处理的异常可能被忽略。使用asyncio.gather(..., return_exceptions=True)或添加回调。
• 新的I/O密集型项目优先使用asyncio。 生态系统成熟，FastAPI和aiohttp等框架使其变得容易。
• 遗留或简单脚本使用线程。 如果你只需要并行化几个阻塞调用，线程侵入性更小。

常见问题

我可以同时使用asyncio和线程吗？

可以。你可以使用asyncio.to_thread()或loop.run_in_executor()在线程池中运行阻塞代码。当你需要从异步代码调用同步库而不阻塞事件循环时，这很有用。

asyncio与GIL兼容吗？

是的，asyncio在单线程中运行并受GIL约束。然而，由于它专为I/O密集型任务设计，GIL在I/O操作期间被释放，允许其他任务运行。对于CPU密集型工作，asyncio不提供加速。

哪个更快：asyncio还是线程？

对于具有许多并发操作的I/O密集型任务，asyncio通常更快且更具可扩展性，因为它避免了线程开销。对于少量阻塞任务，线程可能更简单且性能相似。两者都不有助于CPU密集型任务。

做出正确选择

首先确定你的瓶颈是I/O还是CPU。如果是I/O且需要高并发，选择asyncio。如果是I/O但你处理的是阻塞库或更简单的脚本，线程是可靠的选择。对于CPU密集型工作，使用多进程。

记住，你通常可以组合这些模型——例如，使用asyncio进行网络操作，使用线程池进行文件I/O。关键是理解权衡并选择适合你具体问题的工具。

当你需要快速格式化或验证并发API调用返回的JSON数据时，试试我们的JSON Formatter，轻松美化打印和调试。