GIL 锁是什么?为什么我的 Python 脚本在多核 CPU 上跑不快?

前言：一个让新手崩溃的 “并发陷阱”

作为刚接触 Python 并发编程的同学，你大概率遇到过这种情况：

• 写了个 “多线程脚本” 处理大数据（比如批量爬取、文件处理），满心以为能利用多核 CPU 起飞；

• 运行后打开任务管理器 /htop，发现 CPU 利用率始终卡在 100% 左右（而不是多核的 400%、800%）；

• 脚本跑起来比想象中慢很多，甚至和单线程没差多少 ——“我的多核 CPU 白买了？Python 并发是骗局？”

其实问题的罪魁祸首，就是 Python 世界里大名鼎鼎的 GIL 锁（Global Interpreter Lock，全局解释器锁）。

这篇文章就用「大白话 + 趣味比喻 + 实战案例」，带你彻底搞懂 GIL 锁：它到底是什么？为什么会限制多核性能？以及最重要的 ——初级人员能直接套用的 “绕开 GIL” 实用技巧，让你的多核 CPU 真正跑满！

一、先搞懂：GIL 锁到底是什么？（生活化比喻）

用 “餐厅后厨” 理解 GIL 锁

把 Python 解释器（比如 CPython，我们平时用的默认版本）想象成一个 火爆的餐厅后厨：

• CPU 核心 → 后厨里的厨师（多核就是多个厨师，理论上能同时做菜）；

• Python 线程 → 待做的订单（多个线程就是多个订单，需要厨师处理）；

• GIL 锁 → 后厨的「唯一炒菜锅」。

关键规则来了：

1. 不管有多少个厨师（多核 CPU），同一时间只有一个订单（线程）能拿到炒菜锅（GIL 锁） ；

2. 拿到锅的订单，才能让厨师（CPU）处理；没拿到锅的订单，只能排队等；

3. 每个订单拿到锅后，最多炒一会儿（默认 100 个时钟滴答），就必须把锅让给下一个订单（线程切换）。

GIL 锁的核心本质

GIL 是 CPython 解释器加的一把「全局互斥锁」，目的是保证同一时间，只有一个 Python 线程能执行字节码。

哪怕你的电脑有 8 核 CPU，Python 多线程程序也只能「交替使用」一个核心 —— 表面上是 “多线程并发”，实际上是 “单线程串行”，多核 CPU 的性能完全没利用起来！

补充：为什么 CPython 要加 GIL？

不是开发者想不开，而是历史原因导致的 “无奈之举”：

• 早期 CPython 为了简化内存管理（比如垃圾回收），加了 GIL 锁 —— 这样不用考虑多个线程同时操作内存的 “冲突问题”；

• 后来 Python 生态越来越庞大，很多第三方库（比如 numpy、requests）都是基于 GIL 设计的，想去掉 GIL 已经牵一发而动全身。

总结 GIL：它是 CPython 的 “历史遗留锁”，让 Python 多线程变成了 “伪并发”，多核 CPU 只能 “排队干活”。

二、灵魂拷问：为什么多核 CPU 上 Python 脚本跑不快？

先看一个 “打脸” 的实战案例

我们用代码实测：单线程 vs 多线程 处理 “计算密集型任务”（比如循环计算），看看多核性能到底怎么样。

代码准备（直接复制运行）

import timeimport threading# 计算密集型任务：循环计数（模拟耗时计算）def count_down(n):   while n > 0:       n -= 1# 单线程执行start_time = time.time()count_down(100000000)  # 1亿次循环end_time = time.time()print(f"单线程耗时：{end_time - start_time:.2f} 秒")# 多线程执行（2个线程，分拆任务）start_time = time.time()t1 = threading.Thread(target=count_down, args=(50000000,))t2 = threading.Thread(target=count_down, args=(50000000,))t1.start()t2.start()t1.join()t2.join()end_time = time.time()print(f"双线程耗时：{end_time - start_time:.2f} 秒")

运行结果（以 4 核 CPU 为例）

单线程耗时：4.87 秒双线程耗时：4.92 秒

惊不惊喜？意不意外？ 双线程不仅没快，反而慢了一点点！

原因拆解：GIL 锁的 “副作用”

1. 线程切换有开销：多线程需要不断切换 “拿锅权”，切换过程会消耗 CPU 资源（比如保存线程状态、唤醒下一个线程）；

2. 计算密集型任务 “抢锅” 严重：计算密集型任务（比如循环、数学运算）几乎一直在占用 CPU，线程切换频繁，GIL 锁的 “排队成本” 远大于 “并行收益”；

3. 多核完全被浪费：哪怕有 8 核 CPU，也只有一个核心在干活，其他核心都在 “摸鱼”。

关键结论：GIL 锁的 “影响范围”

不是所有 Python 程序都会被 GIL 限制！分两种场景：

比如：用多线程爬取 100 个网页（IO 密集型），因为大部分时间在等网络响应，线程切换成本低，能比单线程快 5~10 倍；但用多线程做 100 次数学运算（计算密集型），GIL 会让多核完全没用。

三、实用技巧：3 种 “绕开 GIL” 的方法（初级人员直接套用）

既然 GIL 锁限制了多核性能，那我们该怎么让 Python 利用多核 CPU？分享 3 种 简单、实用、新手能快速上手 的方法，从易到难排序。

方法 1：用 multiprocessing 模块（多进程，最推荐）

核心原理：每个进程都有独立的 GIL 锁

GIL 锁是「进程级」的，不是「系统级」的 —— 每个 Python 进程都有自己的解释器和独立的 GIL 锁。

相当于：不再是 “一个后厨抢一口锅”，而是直接开「多个独立的后厨」，每个后厨都有自己的锅和厨师，各个后厨并行干活，互不干扰！

实战案例：多进程处理计算密集型任务

把上面的多线程代码改成多进程，只需要改 2 行！

import timefrom multiprocessing import Process  # 1. 导入多进程模块defcount_down(n):while n > 0:       n -= 1# 多进程执行（2个进程，分拆任务）start_time = time.time()p1 = Process(target=count_down, args=(50000000,))  # 2. 把 Thread 改成 Processp2 = Process(target=count_down, args=(50000000,))p1.start()p2.start()p1.join()p2.join()end_time = time.time()print(f"双进程耗时：{end_time - start_time:.2f}秒")

运行结果（4 核 CPU）

双进程耗时：2.51 秒

直接提速 1 倍！ 如果用 4 个进程，耗时会进一步降到 1.3 秒左右，真正利用了多核 CPU。

新手注意事项（避坑重点）

1. 进程开销比线程大：每个进程都有独立的内存空间，创建和销毁的成本比线程高，所以不要创建太多进程（建议进程数 = CPU 核心数）；

2. 数据共享麻烦：进程间不能直接共享变量（比如全局变量），需要用 Queue 或 Pipe 传递数据（后面会给示例）；

3. 适用场景：计算密集型任务（循环、运算、数据处理），优先用多进程。

方法 2：用 concurrent.futures 模块（简化多进程 / 多线程，新手友好）

如果觉得 multiprocessing 模块的代码有点繁琐，推荐用 concurrent.futures——Python 3.2+ 内置的 “并发工具包”，封装了多进程和多线程，一行代码就能实现并发，新手闭眼用！

核心优势：

• 不用手动管理进程 / 线程的创建、启动、等待；

• 支持 “线程池” 和 “进程池”，自动控制并发数量；

• 代码简洁，学习成本极低。

实战案例 1：进程池处理计算密集型任务

import timefrom concurrent.futures import ProcessPoolExecutor  # 进程池defcount_down(n):while n > 0:       n -= 1return"任务完成"start_time = time.time()# 创建进程池，最大进程数 = CPU 核心数（默认值）with ProcessPoolExecutor() as executor:# 提交 2 个任务到进程池   future1 = executor.submit(count_down, 50000000)   future2 = executor.submit(count_down, 50000000)# 获取任务结果print(future1.result())print(future2.result())end_time = time.time()print(f"进程池耗时：{end_time - start_time:.2f}秒")

实战案例 2：线程池处理 IO 密集型任务

对于 IO 密集型任务（比如爬取网页），用线程池更高效（开销小）：

import timeimport requestsfrom concurrent.futures import ThreadPoolExecutor  # 线程池# IO 密集型任务：爬取网页deffetch_url(url):   response = requests.get(url)returnf"{url}→状态码：{response.status_code}"# 待爬取的网页列表urls = ["https://www.baidu.com","https://www.taobao.com","https://www.jd.com","https://www.zhihu.com"]# 单线程爬取start_time = time.time()for url in urls:print(fetch_url(url))print(f"单线程耗时：{time.time() - start_time:.2f}秒")# 线程池爬取（4个线程）start_time = time.time()with ThreadPoolExecutor(max_workers=4) as executor:# 批量提交任务，返回结果迭代器   results = executor.map(fetch_url, urls)for res in results:print(res)print(f"线程池耗时：{time.time() - start_time:.2f}秒")

运行结果

https://www.baidu.com →状态码：200https://www.taobao.com →状态码：200https://www.jd.com →状态码：200https://www.zhihu.com →状态码：200单线程耗时：1.87秒https://www.baidu.com →状态码：200https://www.taobao.com →状态码：200https://www.jd.com →状态码：200https://www.zhihu.com →状态码：200线程池耗时：0.52秒

提速 3 倍以上！ 因为 IO 密集型任务大部分时间在等网络响应，线程切换成本低，GIL 锁几乎不影响。

方法 3：用 C 扩展 / 第三方库（绕开 GIL，无需改代码）

如果不想改代码，还有一个 “懒人方案”：用不被 GIL 限制的第三方库。

原理：GIL 只限制 Python 字节码的执行，而用 C/C++ 编写的扩展库（比如 numpy、scipy），在执行底层 C 代码时，会暂时释放 GIL 锁，让多个线程能真正并行执行。

实战案例：用 numpy 处理数据（自动绕开 GIL）

import timeimport numpy as npimport threading# 用 numpy 做计算（C 扩展实现，释放 GIL）defnumpy_calc():   arr = np.random.rand(10000, 10000)  # 创建 10万 x 10万的数组   arr = arr * arr  # 矩阵乘法（计算密集型）# 多线程执行 numpy 任务start_time = time.time()t1 = threading.Thread(target=numpy_calc)t2 = threading.Thread(target=numpy_calc)t1.start()t2.start()t1.join()t2.join()end_time = time.time()print(f"numpy 多线程耗时：{end_time - start_time:.2f}秒")# 单线程执行start_time = time.time()numpy_calc()numpy_calc()end_time = time.time()print(f"numpy 单线程耗时：{end_time - start_time:.2f}秒")

运行结果

numpy 多线程耗时：1.23 秒numpy 单线程耗时：2.31 秒

多线程提速明显！ 因为 numpy 的底层是 C 代码，执行时释放了 GIL 锁，真正利用了多核 CPU。

常用的 “绕 GIL” 库：

• 数据处理：numpy、pandas（底层 C 实现）；

• 网络请求：gevent（基于协程，自动切换 IO）；

• 深度学习：tensorflow、pytorch（GPU 加速，绕开 CPU 的 GIL）。

四、趣味实战：写一个 “多核性能测试工具”（实用 + 成就感）

学会了上面的方法，我们来写一个趣味小工具：测试自己的 CPU 核心数，以及多进程 vs 单线程的性能差距，新手也能写出 “高大上” 的工具！

完整代码（直接复制运行）

import timeimport multiprocessingfrom concurrent.futures import ProcessPoolExecutordefcpu_intensive_task():"""CPU 密集型任务：计算质数"""   count = 0for num inrange(2, 100000):       is_prime = Truefor i inrange(2, int(num**0.5) + 1):if num % i == 0:               is_prime = Falsebreakif is_prime:           count += 1return countdefmain():# 获取 CPU 核心数   cpu_count = multiprocessing.cpu_count()print(f"=== 你的 CPU 核心数：{cpu_count} ===")# 1. 单线程测试print("n🚀单线程测试开始...")   start_time = time.time()   cpu_intensive_task()   single_time = time.time() - start_timeprint(f"单线程耗时：{single_time:.2f}秒")# 2. 多进程测试（进程数 = CPU 核心数）print("n🚀多进程测试开始（进程数 = CPU 核心数）...")   start_time = time.time()with ProcessPoolExecutor(max_workers=cpu_count) as executor:# 提交和 CPU 核心数相同的任务       futures = [executor.submit(cpu_intensive_task) for _ inrange(cpu_count)]# 获取结果（确保任务完成）       [future.result() for future in futures]   multi_time = time.time() - start_timeprint(f"多进程耗时：{multi_time:.2f}秒")# 3. 计算提速倍数   speedup = single_time / multi_timeprint(f"n🎉多进程比单线程提速：{speedup:.2f}倍！")if __name__ == "__main__":   main()

运行效果（8 核 CPU 示例）

=== 你的 CPU 核心数：8 ===🚀 单线程测试开始...单线程耗时：12.34 秒🚀 多进程测试开始（进程数 = CPU 核心数）...多进程耗时：1.87 秒🎉 多进程比单线程提速：6.60 倍！

看到自己写的工具能跑满多核 CPU，是不是成就感拉满？这个工具还能用来测试不同进程数的性能差异，比如试试 4 进程、8 进程、16 进程的耗时变化～

五、新手必记：GIL 锁 & 并发编程 核心总结

3 个核心结论（记牢少走弯路）

1. GIL 锁是 CPython 的 “专利”：只有默认的 CPython 解释器有 GIL，其他解释器（比如 PyPy）没有，但日常开发几乎不用；

2. 任务类型决定并发方案：

• 计算密集型（循环、运算）→ 用「多进程」（multiprocessing/ProcessPoolExecutor）；

• IO 密集型（网络、文件、数据库）→ 用「多线程」（threading/ThreadPoolExecutor）；

1. 绕开 GIL 的 3 条路
   ：多进程、C 扩展库、换解释器（新手优先前两条）。

新手避坑小贴士

1. 不要用 Python 多线程处理计算密集型任务，纯属浪费时间；

2. 多进程的进程数不要超过 CPU 核心数，否则会因为进程切换导致性能下降；

3. 用多进程时，避免频繁共享数据（比如全局变量），尽量用 Queue 传递数据，减少开销；

4. 日常开发中，优先用 concurrent.futures 模块，代码简洁且不易出错。

结尾：GIL 锁不是 “洪水猛兽”，而是 “入门门槛”

很多新手会因为 GIL 锁觉得 Python 并发 “不行”，但其实 GIL 锁只是 Python 的一个 “特性”，不是 “缺陷”—— 它让 Python 内存管理更简单，新手更容易上手，同时也有成熟的方法绕开它。

作为并发编程初级人员，我们不需要深入理解 GIL 的底层实现，只要记住：根据任务类型选择合适的并发方案，就能让 Python 程序在多核 CPU 上跑满性能。

下次再遇到 “Python 脚本跑不快” 的问题，先问自己两个问题：

1. 我的任务是计算密集型还是 IO 密集型？

2. 我用对并发方案了吗？（计算用多进程，IO 用多线程）

掌握了这些，你就能轻松绕开 GIL 锁的限制，让你的 Python 脚本真正 “飞起来”！