注意点:协程里面跑必须跑同步代码的时候，必须放进线程池或者进程池，然后将线程池或者进程池进行封装，使协程可以异步等待后台线程或后台进程执行任务 -----应该是完整的，后续跟协程一块总结

m0_52935719

320人浏览 · 2026-05-28 10:03:05

m0_52935719 · 2026-05-28 10:03:05 发布

彻底搞懂：asyncio 结合线程池处理阻塞 IO（完整版可直接发博客）

在 Python 异步开发中，asyncio 依托单线程事件循环实现高并发，但它天生无法兼容传统同步阻塞代码。当项目中不得不使用 requests、同步文件读写、老旧第三方库时，ThreadPoolExecutor 就成了主流解决方案。本文完整讲解使用场景、底层原理、代码实战、核心误区、强制规范，帮你彻底理清协程与线程池的协作关系。

一、核心前置结论

asyncio 运行在单一线程中，一旦执行同步阻塞代码，整个事件循环会被冻结，所有协程停止调度。
ThreadPoolExecutor 提供独立线程池，专门承载同步阻塞任务，实现主线程（事件循环）与阻塞任务解耦。
loop.run_in_executor() 是二者的桥梁，将线程任务封装为 asyncio.Future，让协程可以通过 await 异步等待执行结果。
重要误区纠正：该方案并不是“把线程池当成协程使用”，而是协程异步等待后台线程执行任务，线程和协程本质是两套不同的并发模型。

二、asyncio 关键注意点（强制规范）

核心注意点（最标准、最准确、最简洁）

在 asyncio 协程内部，如果必须运行同步阻塞代码（如同步网络请求、同步文件IO、第三方同步库），
绝对不能直接执行，否则会阻塞整个事件循环，导致所有协程卡死。

正确做法只有一种：
把同步代码丢进线程池或进程池执行，
然后将线程池/进程池封装成可 await 的异步对象，
让协程可以异步等待后台线程/进程完成任务，不阻塞主线程。

一句话金句

协程不跑阻塞代码，阻塞代码不进协程；
必须跑就丢线程/进程池，封装后让协程异步等待。

详细规范说明

协程所在的主线程 = 事件循环唯一线程
这个线程一旦被同步代码阻塞，整个异步程序都会停止。
同步阻塞代码必须剥离
如：requests、time.sleep()、open()、同步数据库驱动等。
解决方案：线程池 / 进程池隔离
- IO 密集型：用 ThreadPoolExecutor
- CPU 密集型：用 ProcessPoolExecutor
封装成异步可等待对象
使用 loop.run_in_executor() 将线程/进程池包装成 Future，
让协程可以 await 等待，实现异步非阻塞。

三、为什么必须搭配线程池？

3.1 纯 asyncio 无法处理同步阻塞代码

asyncio 的高并发能力建立在非阻塞 IO + 协程主动切换之上。如果在协程内直接调用同步阻塞函数，当前唯一的主线程会被卡住，事件循环无法调度其他协程，并发特性完全失效。

错误示例（直接在协程中使用同步请求）：

import asyncio
import requests

async def bad_request():
    # 同步阻塞调用，卡死整个事件循环
    resp = requests.get("https://httpbin.org/get")
    print(f"状态码：{resp.status_code}")

async def main():
    # 看似并发，实际串行执行
    await asyncio.gather(bad_request(), bad_request())

asyncio.run(main())

运行现象：两个请求串行执行，无任何并发效果，程序整体响应缓慢。

3.2 线程池的核心作用

将同步阻塞任务剥离到独立子线程执行，主线程的事件循环保持正常运转：

阻塞逻辑在线程池内运行，不占用主线程；
事件循环继续调度其他就绪协程；
任务执行完毕后，通过回调将结果回传给协程。

四、底层原理与伪代码解析

4.1 run_in_executor 工作流程

loop.run_in_executor 是衔接协程与线程池的核心方法，内部分为三步：

将同步函数提交给 ThreadPoolExecutor 执行；
把线程池的任务对象包装为 asyncio.Future；
注册回调，线程任务完成后，通过 set_result/set_exception 唤醒等待的协程。

4.2 核心逻辑伪代码

# 模拟 run_in_executor 底层实现
def run_in_executor(executor, func, *args):
    # 1. 同步函数提交到线程池
    thread_future = executor.submit(func, *args)
    # 2. 创建 asyncio 可等待对象
    async_future = loop.create_future()

    # 3. 线程任务完成后的回调
    def done_callback(fut):
        if fut.cancelled():
            async_future.cancel()
        elif fut.exception():
            async_future.set_exception(fut.exception())
        else:
            async_future.set_result(fut.result())

    thread_future.add_done_callback(done_callback)
    return async_future

五、实战代码：协程 + 线程池标准用法

5.1 完整可运行示例

import asyncio
import requests
from concurrent.futures import ThreadPoolExecutor

# 全局创建线程池，复用线程，避免频繁创建销毁开销
executor = ThreadPoolExecutor(max_workers=10)

async def safe_request(url):
    # 获取当前运行的事件循环
    loop = asyncio.get_running_loop()
    # 将同步阻塞函数交由线程池执行，协程异步等待结果
    resp = await loop.run_in_executor(executor, requests.get, url)
    print(f"请求 {url} 状态码：{resp.status_code}")
    return resp

async def main():
    url_list = [
        "https://httpbin.org/get",
        "https://httpbin.org/delay/1",
        "https://httpbin.org/get"
    ]
    # 并发执行多个协程
    tasks = [safe_request(url) for url in url_list]
    await asyncio.gather(*tasks)

if __name__ == "__main__":
    asyncio.run(main())

5.2 三种方案效果对比

实现方案	执行方式	并发能力	事件循环状态
协程直接调用同步函数	串行执行	无并发	完全阻塞
协程 + ThreadPoolExecutor	多线程并行	高并发	正常运行
纯异步库（aiohttp）	协程调度并发	最高并发	正常运行

六、关键注意事项（避坑指南）

6.1 线程池配置建议

max_workers 无需设置过大，参考 CPU 核心数的 2~4 倍 即可，线程过多会增加系统调度开销；
全局复用同一个线程池，不要在协程内反复创建/销毁线程池。

6.2 适用任务类型

✅ 推荐：IO 密集型任务（网络请求、本地文件读写、同步数据库查询）；
❌ 禁止：CPU 密集型计算任务，受 Python GIL 全局解释器锁限制，多线程无法实现并行，反而降低性能。

6.3 异常捕获

线程内抛出的异常会被封装到 asyncio.Future 中，必须通过 try/except 捕获：

async def safe_request(url):
    loop = asyncio.get_running_loop()
    try:
        resp = await loop.run_in_executor(executor, requests.get, url)
        return resp
    except Exception as e:
        print(f"请求异常：{str(e)}")
        return None