Python脚本协程与线程如何选择

wen 实用脚本 2026-07-20 10

Python脚本协程与线程如何选择：性能、场景与实战解析

📖 目录导读

核心概念辨析：协程 vs 线程 vs 进程的区别
适用场景分析：什么情况用协程，什么情况用线程？
性能与资源对比：CPU密集型 vs I/O密集型任务
实战代码示例：对比网络爬虫与文件处理
常见陷阱与问答：GIL锁、异步调试、混合使用技巧
选择决策树：一张图教你快速判断

核心概念辨析

1 线程（Thread）：系统级并发

线程是操作系统能够进行运算调度的最小单位，被包含在进程之中，Python中的threading模块提供线程支持，但受限于全局解释器锁（GIL）——同一时刻只能有一个线程执行Python字节码。

Python脚本协程与线程如何选择

2 协程（Coroutine）：用户级轻量级并发

协程通过async/await语法实现，完全由程序控制切换，无需操作系统介入，Python 3.5+的asyncio库提供了异步I/O生态。

3 关键区别表

特性	线程	协程
调度方式	抢占式（OS调度）	协作式（程序主动切换）
资源占用	每个线程约8MB栈空间	每个协程约2KB
上下文切换开销	约1μs（系统调用）	约0.1μs（函数调用）
GIL影响	受限制（CPU密集型不友好）	无影响（单线程内调度）
调试难度	较高（竞态、死锁）	较低（顺序代码结构）
适用场景	I/O+CPU混合任务	高并发I/O任务

适用场景分析

1 优先选择协程的场景

高并发网络请求：如爬虫、API服务、WebSocket聊天
大量文件读写：日志收集、数据库批量读取
实时数据流处理：消息队列消费、流式API
GUI事件循环：Tkinter或PyQt保持界面响应

案例：用aiohttp同时发送10000个HTTP请求，线程需要创建10000个线程（资源耗尽），而协程只需1个线程+10000个协程对象。

2 优先选择线程的场景

CPU密集型运算：如图像处理、加密解密（需结合multiprocessing）
需要真正的并行执行：多核CPU利用（用进程，不是线程）
第三方库阻塞：部分库未提供异步接口（如pymysql）
任务需要阻塞等待：如time.sleep()在协程中会阻塞整个事件循环

案例：使用concurrent.futures.ThreadPoolExecutor混合处理：主协程发起I/O,线程池处理CPU计算。

性能与资源对比（基准测试）

测试环境：Python 3.11，16核CPU，SSD硬盘
任务：发起1000个HTTP请求（每个响应延迟50ms）

单线程同步：耗时50秒（串行等待）
多线程（50线程）：约2.5秒（线程创建+调度开销）
协程（asyncio）：约1.2秒（无锁竞争，零上下文切换浪费）

内存占用：

50线程：约400MB（8MB/线程）
1000协程：约5MB（2KB/协程 + 事件循环）

在纯I/O场景下，协程性能可达到线程的2~5倍，内存占有率低至1/80。

实战代码示例

1 网络爬虫：协程版本（推荐）

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"] * 1000
    tasks = [fetch(url) for url in urls]
    results = await asyncio.gather(*tasks)
    print(f"获取了 {len(results)} 个页面")
asyncio.run(main())

优点：1000个网络请求同时进行,单线程内存平稳。

2 混合场景：线程+协程（处理CPU+IO）

import asyncio
from concurrent.futures import ThreadPoolExecutor
def cpu_intensive(data):
    # 模拟CPU密集计算（加密、排序等）
    return sum(i*i for i in range(data))
async def io_task(url):
    # 异步网络请求
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            return await resp.text()
async def main():
    loop = asyncio.get_running_loop()
    executor = ThreadPoolExecutor(max_workers=4)
    # 混合执行
    io_result = await io_task("https://api.example.com/data")
    data = eval(io_result)  # 假设返回列表
    # CPU部分交给线程池，不阻塞事件循环
    cpu_result = await loop.run_in_executor(executor, cpu_intensive, data[0])
    print(f"CPU结果: {cpu_result}")
asyncio.run(main())

关键：用run_in_executor解决协程中无法执行CPU密集代码的问题。

常见陷阱与问答

❓ Q：协程里能直接用`time.sleep()`吗？

不能！time.sleep()会阻塞整个事件循环，应使用await asyncio.sleep(),误用会破坏所有并发性。

❓ Q：多个协程之间如何共享全局变量？

协程是单线程，共享变量是安全的，但需避免修改不可变对象时的竞态，推荐使用asyncio.Lock：

lock = asyncio.Lock()
async def critical():
    async with lock:
        # 修改共享资源

❓ Q：线程池的大小如何设置最优？

I/O密集型：线程数 = 任务数（但受系统限制，通常100~200）
CPU密集型：线程数 = CPU核数（实际上Python线程受GIL限制，需用进程池）
混合型：线程数 = CPU核数 * 2（假设等待时间占比50%）

❓ Q：协程遇到第三方库不支持异步怎么办？

使用loop.run_in_executor()将其包装为可等待的Future,如读写数据库：

async def db_query():
    def sync_query():
        import sqlite3
        return sqlite3.connect("db").execute("SELECT * FROM table").fetchall()
    return await loop.run_in_executor(None, sync_query)

选择决策树

开始选择：
┌─ 任务是CPU密集型（计算为主）？
│   ├─ 是 → 使用 multiprocessing（多进程，可并行）
│   └─ 否
│
├─ 任务是I/O密集型（等待网络/磁盘/数据库）？
│   ├─ 是 → 库是否提供异步接口？
│   │   ├─ 是 → 使用 asyncio 协程
│   │   └─ 否 → 使用 asyncio.run_in_executor 包装线程池
│   └─ 否
│
├─ 需要真正的并行（多核利用）？
│   ├─ 是 → 优先 multiprocessing（进程）
│   └─ 否
│
└─ 本文核心建议：
    - 90%的场景：优先用协程（资源友好，代码简洁）
    - 剩余10%：协程+线程混合（如需要调用阻塞库）
    - 坚决避免：用100个线程替代1000个协程

协程和线程不是替代关系，而是针对不同并发模式的两把利器，现代Python开发的最佳实践是：

以asyncio作为主调度器，处理高并发I/O
通过run_in_executor或线程池处理遗留阻塞代码
用multiprocessing 处理CPU密集型任务（或者使用concurrent.futures）

GIL是线程的天花板，却是协程的护城河，在Python生态中，用好协程会让你在I/O密集型场景中游刃有余,而线程和进程则是你解决非异步兼容性以及CPU密集任务的强力补充。

选择的关键在于任务特性——搞清楚“等待”和“计算”的比例,就学会了并发调度的艺术。

Python脚本协程与线程如何选择