张三：从泥水匠到包工头的故事 *—— 深入浅出讲解 `run_in_executor()` 的工作原理*

普郎特2025-07-27 16:52

run_in_executor()的用法曾经让我困惑了好久。而今天包工头张三的故事，恰好诠释了 run_in_executor() 的核心思想与使用场景。让我们一起来听听，张三是如何从一个亲力亲为的手艺人，蜕变为能调度多线程资源的包工头的。

第一章：张三的困境

张三是一名经验丰富的泥水匠（事件循环对象），这天他接到了三个工地的建房任务：

  • 工地1：普通住宅项目（包含asyncio.sleep的协程函数）
  • 工地2：商业楼盘项目（包含asyncio.sleep的协程函数）
  • 工地3：特殊安全项目（包含阻塞操作time.sleep的任务）

他起初打算一个人亲自完成所有任务------包括工地3。

python 复制代码 
import asyncio
import time
import threading

# 工地1：普通住宅项目
async def worksite_1():
    print("张三：开始工地1的住宅项目")
    for phase in range(3):
        print(f"张三：工地1第{phase+1}阶段施工中...")
        await asyncio.sleep(1)  # 等待材料送达
        print(f"张三：工地1第{phase+1}阶段完成，材料到了继续干活")
    print("张三：工地1住宅项目全部完工！")

# 工地2：商业楼盘项目
async def worksite_2():
    print("张三：开始工地2的商业楼盘")
    for phase in range(3):
        print(f"张三：工地2第{phase+1}阶段施工中...")
        await asyncio.sleep(1.5)  # 等待材料送达
        print(f"张三：工地2第{phase+1}阶段完成，材料到了继续干活")
    print("张三：工地2商业楼盘全部完工！")

# 工地3：特殊安全项目（问题工地）
def special_safety_training(project_name):
    """特殊项目：需要3天安全培训，期间不能离开"""
    worker = threading.current_thread().name
    print(f"工人{worker}：开始{project_name}的安全培训...")
    print(f"工人{worker}：培训期间不能离开现场，专心学习安全知识")
    time.sleep(3)  # 3天培训，阻塞操作
    print(f"工人{worker}：安全培训完成，开始施工")
    print(f"工人{worker}：{project_name}特殊项目完工！")
    return f"{project_name}合格证书"

# 如果张三亲自处理工地3（错误做法）
async def zhang_san_wrong_approach():
    print("=== 错误做法：张三亲自处理所有工地 ===")
    print("张三：我要亲自处理工地3的特殊项目")
    
    # 这里张三被困住了！
    time.sleep(3)  # 张三被迫参加3天培训，其他工地停工
    print("张三：终于完成工地3，但其他工地都耽误了...")

async def test_wrong_approach():
    await asyncio.gather(
        worksite_1(),
        worksite_2(), 
        zhang_san_wrong_approach()
    )

# 运行错误做法看看效果
# asyncio.run(test_wrong_approach())

结果：整个事件循环被阻塞，工地1和工地2的异步任务完全卡住。

第二章：张三的智慧

张三发现了问题：在等待工地1送材料时，不如先去工地2干活，反之亦然。

python 复制代码 
async def zhang_san_smart_work():
    """张三的智慧工作法"""
    print("=== 张三开始智慧工作模式 ===")
    print("张三：今天要处理三个工地，我来合理安排一下")
    
    # 张三在工地间穿梭的工作方式
    await asyncio.gather(
        worksite_1(),
        worksite_2(),
        # 先不处理工地3，看看张三如何在工地1和2之间切换
    )

# asyncio.run(zhang_san_smart_work())

这样，他在多个任务间高效切换，体现了异步的非阻塞优势。

张三的工作智慧：

  1. 在工地1干活，遇到等材料（asyncio.sleep）时，立刻去工地2
  2. 在工地2等材料时，回工地1看看材料到了没有
  3. 这样两个工地的进度都不耽误，效率大大提升

第三章：特殊工地的挑战

但面对工地3，他陷入了思考："3天的安全培训中我不能离开，那我不就动弹不得了吗？"

异步调度根本处理不了这种**"不能中断"的阻塞任务**。

python 复制代码 
async def zhang_san_encounters_problem():
    """张三遇到工地3的特殊要求"""
    print("张三：来到工地3，查看项目要求...")
    print("张三：什么？这个项目要求工作人员必须先参加3天安全培训？")
    print("张三：而且培训期间不能离开现场？这样我就没法去其他工地了...")
    print("张三：这样下去，工地1和工地2的进度会受影响...")
    print("张三：让我想想办法...")
    
    # 张三陷入沉思
    await asyncio.sleep(2)
    print("张三：有了！我想到办法了！")

第四章：张三的华丽转身

作为老江湖，张三有他的解决方案。于是，张三决定------转型当包工头！

python 复制代码 
async def zhang_san_becomes_contractor():
    """张三华丽转身为包工头"""
    print("=== 张三的华丽转身 ===")
    print("张三：翻看手机通讯录，寻找劳务中介公司...")
    print("张三：找到了！给劳务公司打电话")
    
    # 获取事件循环（张三准备升级为包工头）
    loop = asyncio.get_event_loop()
    
    print("张三：喂，劳务公司吗？我需要几个工人帮我处理特殊项目")
    print("劳务公司：好的张三老板，我们马上派工人过去")
    
    # 关键操作：张三把工地3外包给劳务公司
    # 这时张三从泥水匠升级为包工头
    worksite_3_task = loop.run_in_executor(
        None, 
        special_safety_training, 
        "工地3特殊安全项目"
    )
    
    print("张三：工人已经派到工地3了，我现在是包工头了！")
    print("张三：我可以继续在工地1和工地2之间穿梭，同时监督工地3的进度")
    
    # 张三同时管理三个工地
    await asyncio.gather(
        worksite_1(),
        worksite_2(),
        worksite_3_task  # 工地3由工人负责
    )
    
    print("张三：所有工地都完工了！我成功从泥水匠升级为包工头！")

# 运行张三的华丽转身
# asyncio.run(zhang_san_becomes_contractor())

他把工地3交给**劳务公司（线程池）**处理，自己继续在其他工地高效穿梭。

最终：

scss 复制代码 
await asyncio.gather(
    worksite_1(),
    worksite_2(),
    worksite_3_task
)

------三个项目同时推进，张三完成了身份的升级！

第五章：许可证的秘密（GIL机制）

不过，张三的公司只有一张现场施工许可证：（GIL） 。

意味着：

  • 同一时间，只有一个工人能施工（线程间互斥）
  • 哪怕开了多个线程，如果被 GIL 限制，也可能效率有限

这段代码展示了许可证在多个线程间的轮转使用：

python 复制代码 
def detailed_work_with_permit(project_name, duration):
    """详细展示现场施工许可证的使用"""
    worker = threading.current_thread().name
    print(f"[{worker}] 拿到现场施工许可证，开始{project_name}")
    
    for step in range(3):
        print(f"[{worker}] 持证施工：{project_name}第{step+1}步...")
        time.sleep(duration/3)  # 工作期间持有许可证
        # 注意：sleep期间会暂时放下许可证
    
    print(f"[{worker}] {project_name}完工，交还施工许可证")
    return f"{project_name}完工证书"

async def permit_rotation_story():
    """施工许可证流转的故事"""
    print("=== 施工许可证的流转故事 ===")
    print("张三：整个公司只有一张现场施工许可证，同时只能一个工地在使用")
    
    loop = asyncio.get_event_loop()
    
    # 同时启动多个需要许可证的项目
    await asyncio.gather(
        loop.run_in_executor(None, detailed_work_with_permit, "工人A的项目", 2),
        loop.run_in_executor(None, detailed_work_with_permit, "工人B的项目", 2),
        zhang_san_office_work()  # 张三的办公室工作
    )

async def zhang_san_office_work():
    """张三包工头的办公室工作"""
    for task in range(6):
        current_thread = threading.current_thread().name
        print(f"[{current_thread}] 包工头张三：处理办公室业务{task}")
        await asyncio.sleep(0.5)

# 施工许可证流转演示
# asyncio.run(permit_rotation_story())

许可证流转规则：

  1. 同一时间只有一个工地能持有许可证施工
  2. 张三在工地1或工地2干活时必须带着许可证
  3. 工人在工地3干活时，张三必须把许可证借给他们
  4. 当工人休息（time.sleep）时，许可证会被归还，张三可以重新拿到

第六章：完整的包工头工作流

张三的"多工地+管理任务"完美体现了异步+线程池的结合模式：

python 复制代码 
async def zhang_san_full_story():
    """张三完整的包工头故事"""
    print("=== 张三：从泥水匠到包工头的完整故事 ===")
    print(f"张三的身份：{threading.current_thread().name}")
    
    loop = asyncio.get_event_loop()
    
    print("\n第一阶段：张三接到三个工地任务")
    print("张三：工地1和工地2我可以自己处理，但工地3需要特殊处理")
    
    print("\n第二阶段：张三联系劳务公司")
    print("张三：给劳务公司打电话，安排工人去工地3")
    
    print("\n第三阶段：张三升级为包工头，同时管理三个工地")
    
    # 记录开始时间
    import time
    start_time = time.time()
    
    # 同时管理三个工地
    results = await asyncio.gather(
        worksite_1(),                    # 张三亲自处理
        worksite_2(),                    # 张三亲自处理  
        loop.run_in_executor(            # 外包给工人
            None, 
            special_safety_training, 
            "工地3安全项目"
        ),
        zhang_san_management_work()      # 张三的管理工作
    )
    
    end_time = time.time()
    
    print(f"\n第四阶段：所有项目完成")
    print(f"张三：总耗时 {end_time - start_time:.2f} 秒")
    print(f"张三：工地3的结果是：{results[2]}")
    print("张三：我成功从泥水匠转型为包工头！")

async def zhang_san_management_work():
    """张三的包工头管理工作"""
    for task in range(6):
        current_thread = threading.current_thread().name
        print(f"[{current_thread}] 包工头张三：处理办公室业务{task}")
        await asyncio.sleep(0.8)

# 运行完整故事
# asyncio.run(zhang_san_full_story())

他既亲自操作异步任务，又外包阻塞任务，还能腾出手来做项目管理！

第七章：角色对应关系

故事角色 技术概念 含义说明
张三（泥水匠） 事件循环（主线程） 负责调度异步任务
工地1、工地2 异步任务 使用 asyncio.sleep()，非阻塞等待
工地3 阻塞任务 使用 time.sleep()，必须外包
劳务公司 线程池 ThreadPoolExecutor 外包机制
工人 工作线程 执行具体阻塞任务
许可证 GIL 同时只有一个线程在执行 Python 字节码

总结：run_in_executor 的四点启示

  1. 问题识别：知道哪些任务会阻塞整个异步流程
  2. 任务外包 ：通过 run_in_executor() 合理释放主线程
  3. 资源竞争：理解 GIL 的瓶颈与线程调度的边界
  4. 高效协作：异步任务 + 阻塞任务并行推进，实现最大性能

张三的成长启示

通过张三从泥水匠到包工头的故事，我们学到了：

  • 泥水匠阶段：发现某些任务会阻塞整个工作流程
  • 包工头转型：学会合理外包，专注核心调度
  • 许可证机制：理解GIL的工作原理和资源竞争
  • 并发协作：多个项目同时进行，效率大幅提升

最后的提醒

下次在异步代码中碰到阻塞操作时，先别急着硬刚，问问自己：

💡 "如果我是张三，我会怎么做？"

张三的故事告诉我们：在异步编程的世界里，run_in_executor()不仅仅是一个技术工具，更是一种智慧------知道什么时候该亲力亲为，什么时候该合理外包。

记住张三的故事，下次遇到异步代码中的阻塞操作时，就问问自己：张三会怎么做？

希望张三的成长故事能帮助你更好地理解异步编程中的线程池使用。如果你觉得这篇故事对你有启发，欢迎点赞、收藏和关注！下次我们再聊其他有趣的编程话题。

相关推荐
mortimer1 小时前
安装NVIDIA Parakeet时，我遇到的两个Pip“小插曲”
python·github
@昵称不存在1 小时前
Flask input 和datalist结合
后端·python·flask
赵英英俊2 小时前
Python day25
python
东林牧之2 小时前
Django+celery异步：拿来即用，可移植性高
后端·python·django
何双新2 小时前
基于Tornado的WebSocket实时聊天系统：从零到一构建与解析
python·websocket·tornado
AntBlack3 小时前
从小不学好 ，影刀 + ddddocr 实现图片验证码认证自动化
后端·python·计算机视觉
凪卄12133 小时前
图像预处理 二
人工智能·python·深度学习·计算机视觉·pycharm
巫婆理发2223 小时前
强化学习（第三课第三周）
python·机器学习·深度神经网络
seasonsyy3 小时前
1.安装anaconda详细步骤（含安装截图）
python·深度学习·环境配置
半新半旧4 小时前
python 整合使用 Redis
redis·python·bootstrap
热门推荐
01Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code02全球最强模型Grok4，国内已可免费使用！（附教程）03vue数据变化但页面不变04KGG转MP3工具|非KGM文件|解密音频05扣子开源本地部署教程 丨Coze智能体小白喂饭级指南06干翻 Typora！MilkUp：完全免费的桌面端 Markdown 编辑器！07【2025.7.18】更新vscode后所有.vue文件template标签后报红的临时解决办法，Vue - Official 插件3.0.2导致08ChatGPT Agent 完全使用指南：2025年7月最新功能详解09《魔兽世界》提示lua警告的含义及解决方法10Claude Code用不了？来试下Qwen3-Coder加持的Qwen Code吧