Python多任务：并发与并行全解析

小伙伴们对文章编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《Python多任务实现：并发与并行详解》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

Python实现多任务的核心在于根据任务类型选择合适的模块。1. 对于CPU密集型任务，应使用multiprocessing模块，通过创建独立进程绕过GIL限制，真正实现并行计算；2. 对于I/O密集型任务，可选用threading或asyncio模块，其中threading适用于传统并发场景，而asyncio通过事件循环和协程实现高效异步I/O处理，适合高并发网络服务、爬虫等场景。

Python实现多任务，核心在于理解并发与并行。简单来说，就是让程序同时处理多件事，这主要通过标准库中的threading、asyncio（侧重并发）和multiprocessing（侧重并行）模块来完成。它们各自有其适用场景和内在机制，选择哪个，往往取决于你任务的性质。

解决方案

要让Python程序同时处理多项任务，我们通常会考虑三种主要策略：线程（threading）、进程（multiprocessing）和异步I/O（asyncio）。这三者各有千秋，理解它们背后的原理，尤其是Python全局解释器锁（GIL）的影响，是做出正确选择的关键。

对于CPU密集型任务，比如大量计算，我们倾向于使用multiprocessing模块。它通过创建独立的进程来规避GIL的限制，每个进程都有自己的Python解释器和内存空间，因此可以真正利用多核CPU并行执行任务。

import multiprocessing
import time

def cpu_bound_task(n):
    result = sum(i*i for i in range(n))
    return result

if __name__ == "__main__":
    start_time = time.time()
    # 创建多个进程来执行CPU密集型任务
    with multiprocessing.Pool(processes=4) as pool:
        # 假设我们要计算四次相同的大任务
        results = pool.map(cpu_bound_task, [10**7, 10**7, 10**7, 10**7])

    print(f"多进程CPU密集型任务耗时: {time.time() - start_time:.4f} 秒")
    print(f"结果: {results}")

而对于I/O密集型任务，比如网络请求、文件读写或者等待数据库响应，threading模块和asyncio模块则更为常见。尽管threading受GIL限制，无法真正并行执行CPU操作，但在等待I/O时，Python解释器会释放GIL，允许其他线程运行。这使得它在处理大量并发I/O时依然有效。

import threading
import time
import requests # 假设有网络请求

def io_bound_task(url):
    print(f"开始下载: {url}")
    try:
        response = requests.get(url, timeout=5) # 模拟网络请求
        print(f"下载完成: {url}, 状态码: {response.status_code}")
    except requests.exceptions.RequestException as e:
        print(f"下载失败: {url}, 错误: {e}")

if __name__ == "__main__":
    urls = [
        "https://www.baidu.com",
        "https://www.google.com", # 在国内可能无法访问
        "https://www.bing.com",
        "https://www.yahoo.com"
    ]

    start_time = time.time()
    threads = []
    for url in urls:
        thread = threading.Thread(target=io_bound_task, args=(url,))
        threads.append(thread)
        thread.start()

    for thread in threads:
        thread.join() # 等待所有线程完成

    print(f"多线程I/O密集型任务耗时: {time.time() - start_time:.4f} 秒")

asyncio则是Python处理并发I/O的现代方式，它通过事件循环（event loop）和协程（coroutines）实现协作式多任务。它在单个线程内运行，因此没有GIL的并行限制，但要求你的代码是“可等待的”（awaitable），通常用于构建高性能的网络服务。

import asyncio
import aiohttp # 异步HTTP客户端库

async def async_io_bound_task(url):
    print(f"异步开始下载: {url}")
    async with aiohttp.ClientSession() as session:
        try:
            async with session.get(url, timeout=5) as response:
                print(f"异步下载完成: {url}, 状态码: {response.status}")
        except aiohttp.ClientError as e:
            print(f"异步下载失败: {url}, 错误: {e}")

async def main_async():
    urls = [
        "https://www.baidu.com",
        "https://www.google.com", # 在国内可能无法访问
        "https://www.bing.com",
        "https://www.yahoo.com"
    ]
    tasks = [async_io_bound_task(url) for url in urls]
    await asyncio.gather(*tasks)

if __name__ == "__main__":
    start_time = time.time()
    asyncio.run(main_async())
    print(f"异步I/O密集型任务耗时: {time.time() - start_time:.4f} 秒")

Python中的“并发”究竟意味着什么？它和“并行”有何不同？

说实话，这俩概念刚接触时确实挺容易混淆的。我个人喜欢用一个比喻来解释：想象你是一个咖啡师。

并发（Concurrency）：你一个人（一个CPU核心）在同时处理多位顾客的订单。你可能先给A顾客磨豆，磨到一半，B顾客来了，你放下A的豆子去给B打奶泡，奶泡打好了再回来给A冲咖啡。虽然你“看起来”同时在服务多位顾客，但实际上在任何一个瞬间，你都只在做一件事。Python的threading就是这种模式，尤其在I/O操作时，它能切换到另一个线程，让等待时间不被浪费。asyncio也是并发，它更像是你规划好了所有步骤，知道什么时候可以暂停当前任务去处理另一个，效率更高。

并行（Parallelism）：现在你不是一个人了，你和你的同事们（多个CPU核心）都在各自的咖啡机前，同时为不同的顾客制作咖啡。A顾客的咖啡由你制作，B顾客的咖啡由你的同事制作，大家互不干扰，真正地同时进行。Python的multiprocessing就是这种模式，每个进程都在独立的CPU核心上运行，互不影响，可以真正地同时执行计算任务。

核心区别在于：并发是“看起来同时进行”，通过快速切换任务来实现；并行是“真正同时进行”，需要多个处理器核心支持。Python的GIL（全局解释器锁）是理解这一点的关键。它确保了在任何给定时刻，只有一个线程能执行Python字节码。这意味着，即使你启动了多个线程，它们也无法在多核CPU上同时执行CPU密集型任务。但multiprocessing因为创建了独立的进程，每个进程都有自己的解释器，所以可以绕过GIL，实现真正的并行。

什么时候该用threading，什么时候又该选择multiprocessing？

这是一个非常实际的问题，我自己在项目里做技术选型时也经常会纠结。我的经验是，关键在于判断你的任务是“I/O密集型”还是“CPU密集型”。

如果你的任务大部分时间都在等待外部资源，比如等待网络响应、等待文件读写完成、等待数据库查询结果，那么这通常是I/O密集型任务。这种情况下，threading或者asyncio会是更好的选择。当一个线程发起I/O请求并进入等待状态时，GIL会被释放，允许其他线程继续执行Python代码。这样，CPU就不会闲置，程序的整体吞吐量就能提升。比如，你要同时从几十个网站抓取数据，用线程池或asyncio来并发请求，效率会比单线程挨个请求高得多。我个人在写一些爬虫或者并发API调用时，通常会优先考虑asyncio，因为它在处理大量并发连接时，资源消耗和性能表现都非常出色。如果项目历史原因或者逻辑简单，threading也是个不错的选择，它更符合传统的多线程编程思维。

相反，如果你的任务需要大量的计算，比如图像处理、科学计算、数据分析中的复杂算法执行，并且这些计算几乎不涉及等待外部资源，那么这属于CPU密集型任务。在这种情况下，threading几乎帮不上忙，因为GIL会阻止多个线程同时在多核上执行Python字节码。你需要使用multiprocessing。通过创建多个进程，每个进程运行在独立的CPU核心上，它们各自拥有独立的Python解释器，完全避开了GIL的限制，从而实现真正的并行计算，显著缩短总运行时间。当然，进程间通信（IPC）会引入一些额外的复杂性，比如共享内存、队列、管道等，你需要仔细设计这些部分。

简单总结一下：

• I/O密集型：threading (传统、简单) 或 asyncio (现代、高效、适合高并发)。
• CPU密集型：multiprocessing (真正并行，但进程间通信复杂)。

Python的异步编程（asyncio）是多任务的未来吗？它适合哪些场景？

“未来”这个词可能有点重，但asyncio无疑是Python在处理高并发I/O任务方面的一个非常重要的发展方向，并且在很多领域已经成为主流。我个人认为，对于某些特定类型的应用，它确实代表了更高效、更优雅的解决方案。

asyncio的核心思想是“协作式多任务”和“事件循环”。它不是通过操作系统线程的抢占式调度来实现并发，而是通过async和await关键字，让程序员明确地指示代码在何时可以暂停当前任务，去处理其他等待中的任务。当一个协程遇到await一个I/O操作时，它会把控制权交还给事件循环，事件循环就可以去执行其他已经准备好的协程，直到之前等待的I/O操作完成，再回来继续执行。

这种模式的优势非常明显：

1. 极高的并发能力：由于所有任务都在一个线程内运行，上下文切换的开销远小于多线程，可以轻松处理成千上万的并发连接。
2. 避免GIL问题：因为它本身就是单线程的，所以不存在GIL限制CPU密集型任务并行的问题（当然，它也无法让CPU密集型任务并行）。
3. 资源消耗低：协程比线程轻量得多，创建和销毁的开销很小，内存占用也更少。
4. 代码结构清晰：通过async/await，异步代码看起来更像同步代码，避免了回调地狱（callback hell）的问题，提高了可读性和可维护性。

那么，它适合哪些场景呢？

• 高性能网络服务：构建Web服务器（如FastAPI、Sanic）、API网关、WebSocket服务器等，需要同时处理大量并发连接的场景。
• 网络爬虫/数据抓取：需要同时向大量网站发起请求并等待响应，asyncio能显著提高抓取效率。
• 实时数据处理：例如处理消息队列（Kafka、RabbitMQ）中的大量消息，或者构建流式数据处理系统。
• 数据库操作：当使用支持异步的数据库驱动时，可以高效地并发执行数据库查询。

当然，asyncio也有它的学习曲线。你需要改变一些传统的编程思维，习惯async/await的语法，并且确保你使用的所有库都有对应的异步版本（或者能够很好地与异步代码集成）。如果你的任务主要是CPU密集型，或者涉及大量阻塞式的同步I/O操作且无法替换为异步库，那么asyncio可能不是最佳选择，你可能还是需要考虑multiprocessing。但对于现代Web服务和网络应用，asyncio无疑提供了一个强大且优雅的解决方案。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。