【python教程】多任务之进程、线程、协程之间的区别与联系

大家好，我是讯享网，很高兴认识大家。这里提供最前沿的Ai技术和互联网信息。

大家好，我是那个总被产品经理问“为啥系统这么慢”的架构师。今天不甩锅，就聊聊技术。Python 的并发，是个老生常谈但又极其关键的话题。选错了模型，轻则性能上不去，重则系统直接崩给你看。所以，搞清楚这三兄弟的脾气秉性，至关重要。

多进程（Multiprocessing）：简单粗暴，开“分身”，每个分身都有独立的内存空间。绕开 GIL，吃满 CPU。适合 CPU 密集型任务。
多线程（Threading）：轻量级“分身”，共享内存。受制于 GIL，同一时间只有一个线程能跑 Python 代码。但在 I/O 等待时会释放 GIL，所以适合 I/O 密集型任务。
协程（Asyncio）：单线程里的“魔法”，通过 async/await 实现协作式多任务。极致高效，但要求所有 I/O 操作都是异步的。是现代高并发 I/O 应用的首选。

当你有一个任务，比如图像处理、科学计算、或者跑一个复杂的算法，需要把 CPU 榨干，那就别犹豫，上多进程。

from multiprocessing import Pool import time

def cpu_bound_task(n):

"""一个纯CPU计算任务""" total = sum(i * i for i in range(n)) return total

if name == “main”:

numbers = [5_000_000] * 4 # 单进程 start = time.time() results = [cpu_bound_task(n) for n in numbers] print(f"单进程耗时: {time.time() - start:.2f}s") # 多进程 start = time.time() with Pool(processes=4) as pool: results = pool.map(cpu_bound_task, numbers) print(f"多进程耗时: {time.time() - start:.2f}s")

跑一下，你会发现多进程版本快了将近4倍（假设你有4核）。因为它真的把活分给了4个独立的 Python 解释器进程去干，完美绕开了 GIL。

缺点也很明显：进程间通信（IPC）成本高，内存不共享，启动和切换开销大。

如果你的任务大部分时间都在等，比如等网络请求、等磁盘读写、等数据库响应，那么多线程依然是个非常靠谱的选择。

这里就轮到我们的主角 电科金仓 KES 上场了。KES 是一款面向全行业关键应用的企业级大型通用融合数据库，功能强大，稳定可靠（想深入了解？点这里）。我们用官方的 ksycopg2 驱动来连接它，驱动可以从这里下载。

假设我们要同时查询多个用户的订单信息：

import threading

import ksycopg2 import time

def query_user_orders(user_id):

"""查询单个用户的订单""" conn = None try: conn = ksycopg2.connect( database="test", user="user", password="pass", host="127.0.0.1", port="54321" ) cur = conn.cursor() # 模拟一个需要一点时间的查询 cur.execute("SELECT COUNT(*) FROM orders WHERE user_id = %s", (user_id,)) count = cur.fetchone()[0] print(f"用户 {user_id} 有 {count} 个订单") except Exception as e: print(f"查询失败: {e}") finally: if conn: conn.close()

多线程并发查询

user_ids = [1, 2, 3, 4] threads = []

start = time.time() for uid in user_ids:

t = threading.Thread(target=query_user_orders, args=(uid,)) threads.append(t) t.start()

for t in threads:

t.join()

print(f”多线程总耗时: {time.time() - start:.2f}s”)

虽然 CPython 有 GIL，但当 cur.execute() 发起数据库查询并等待 KES 服务器响应时，这个线程会主动释放 GIL。这时，其他线程就能拿到 GIL 去发起自己的查询。最终，四个查询几乎是“同时”在等待数据库，总耗时接近于最慢的那个单次查询，而不是四次查询的总和。

这就是多线程在 I/O 场景下的威力。

多线程虽好，但线程本身也有开销，而且共享内存带来了锁、竞态条件等一系列复杂问题。协程提供了一种更优雅的解决方案。

但是！协程有个硬性前提：你所有的 I/O 操作都必须是“异步”的。这意味着你需要一个支持 asyncio 的数据库驱动。

对于电科金仓 KES，目前主流的 ksycopg2 是同步驱动，不能直接用于 asyncio。不过，我们可以使用像 aiopg 这样的异步 PostgreSQL 驱动（因为 KES 高度兼容 PG 协议），或者期待未来官方推出原生的异步驱动。

下面是一个使用 aiopg 的概念示例：

import asyncio import aiopg async def async_query_user_orders(pool, user_id):
 """异步查询单个用户的订单""" async with pool.acquire() as conn: async with conn.cursor() as cur: await cur.execute("SELECT COUNT(*) FROM orders WHERE user_id = %s", (user_id,)) count = await cur.fetchone() print(f"用户 {user_id} 有 {count[0]} 个订单") 
 async def main():
 # 创建一个异步连接池 dsn = 'dbname=test user=user password=pass host=127.0.0.1 port=54321' async with aiopg.create_pool(dsn) as pool: user_ids = [1, 2, 3, 4] # 并发执行所有查询 await asyncio.gather(*[async_query_user_orders(pool, uid) for uid in user_ids]) 
 启动事件循环
 asyncio.run(main())

这段代码在一个线程里，通过事件循环（Event Loop）管理了4个“看似并发”的任务。当一个任务在 await 数据库响应时，事件循环会立刻切换到另一个准备好的任务去执行。整个过程没有线程切换的开销，也没有锁的问题，效率极高。

协程的缺点就是生态依赖。如果某个关键库没有异步版本，你的整个异步链条就断了。

CPU 密集型（如数据处理、机器学习推理）：果断选 多进程。这是唯一能真正利用多核的方式。
I/O 密集型，且已有成熟的同步库（如 requests, psycopg2/ksycopg2）：多线程 是最简单、最稳妥的选择。开发快，心智负担小。
超高并发 I/O 密集型（如 Web API、实时聊天服务），且核心依赖都有异步版本：协程（asyncio） 是终极答案。它能以极低的资源消耗支撑数万甚至数十万的并发连接。

对于我们日常对接 电科金仓 KES 这类数据库的后端服务，大多数场景都是 I/O 密集型。如果你追求快速交付和稳定性，用 ksycopg2 + 多线程 或 多进程（每个进程内用单线程） 是非常好的选择。如果你在构建下一代超高性能网关或微服务，并且愿意投入精力去适配异步生态，那么 asyncio 将为你打开新世界的大门。

记住，没有银弹。最好的架构，永远是基于对业务场景、技术栈和团队能力的深刻理解之上做出的权衡。

【python教程】多任务之进程、线程、协程之间的区别与联系

多线程并发查询

启动事件循环

相关推荐