python GIL 详解
python GIL 详解
一、GIL 是什么？
局解释器锁（Global Interpreter Lock, GIL） 是 Python 解释器（特别是 CPython）中的一种互斥锁机制。它的核心特点是：在任何时刻，只允许一个线程执行 Python 字节码。这意味着：
即使在多核 CPU 环境下，多线程 Python 程序也无法实现真正的并行计算GIL 不是 Python 语言特性，而是 CPython 实现的产物其他实现（如 Jython、IronPython）没有 GIL
二、为什么 Python 要引入 GIL？
内存管理的复杂性 Python 使用引用计数作为垃圾回收的主要机制之一。每个对象都有一个引用计数器，每当有一个新的引用指向该对象时计数器加一，当引用失效时减一。当计数器归零时，对象所占内存会被释放。 由于引用计数操作本身并不是原子的，因此在多线程环境下，如果多个线程同时修改同一个对象的引用计数，就可能导致数据竞争和内存错误。
为了解决这个问题，有两种方案：
在所有可能修改引用计数的地方都加上细粒度的锁（代价高且复杂）；引入一个全局锁，保证任意时刻只有一个线程在运行（即 GIL）。 显然，后者更容易实现，也更稳定可靠。
提升单线程性能 在单线程场景下，没有上下文切换和锁竞争的开销，引入GIL可以显著提升性能。
三、Python 为什么选择了 GIL ？
首先，它简化了 CPython 的实现，尤其是对于那些不是线程安全的 C 库，使得它们更容易集成到 Python 中。其次，GIL 提供了良好的单线程性能，这对于许多应用场景来说至关重要。尽管 GIL 限制了多线程程序的并行性，但它减少了因引入多个锁而可能导致的死锁风险，并且降低了由频繁申请和释放锁引起的性能损耗。
方案优点缺点GIL实现简单，避免死锁多线程无法并行细粒度锁允许真正并行实现复杂，性能可能下降无锁+GC完全并行（如Java）内存管理开销大，兼容性破坏
四、GIL 对 Python 多线程开发者的影响
任务类型GIL 影响现象CPU 密集型严重限制多线程比单线程更慢I/O 密集型影响较小多线程显著提升性能混合任务部分限制需要针对性优化
五、为什么 GIL 锁至今都没有被移除？
现有的大量依赖 GIL 的 C 扩展模块需要重写，成本巨大。简单的移除 GIL 可能会导致单线程性能下降。
六、GIL 影响的代码示例
示例一：单线程与多线程 CPU 密集型任务对比
这个例子展示了计算密集型任务在单线程和多线程下的性能差异，以说明 GIL 对多线程程序的影响。
import threading
import time
# 模拟一个 CPU 密集型任务
def cpu_bound_task(n):
count = 0
while count < n:
count += 1
# 单线程执行
start_time = time.time()
cpu_bound_task(10**8)
cpu_bound_task(10**8)
print(f"Single thread: {time.time() - start_time} seconds")
# 多线程执行
start_time = time.time()
thread1 = threading.Thread(target=cpu_bound_task, args=(10**8,))
thread2 = threading.Thread(target=cpu_bound_task, args=(10**8,))
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print(f"Multi-threading: {time.time() - start_time} seconds")
输出结果
Single thread: 3.4756979942321777 seconds
Multi-threading: 3.5140140056610107 seconds
结果分析：
在单线程模式下，CPU 密集型任务直接完成。在多线程模式下，由于 GIL 的限制，两个线程实际上串行执行，比单线程更慢，因为增加了线程创建和上下文切换的开销。
示例二：I/O 密集型任务中多线程的优势
对于 I/O 密集型任务，比如文件读写或网络请求，多线程可以显著提升性能，因为线程可以在等待 I/O 操作时释放 GIL，允许其他线程运行。
import threading
import time
# 模拟 I/O 密集型任务
def io_bound_task():
time.sleep(1) # 模拟等待 I/O 完成
# 单线程执行
start_time = time.time()
io_bound_task()
io_bound_task()
print(f"Single thread: {time.time() - start_time} seconds")
# 多线程执行
start_time = time.time()
thread1 = threading.Thread(target=io_bound_task)
thread2 = threading.Thread(target=io_bound_task)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print(f"Multi-threading: {time.time() - start_time} seconds")
输出结果
Single thread: 2.004991054534912 seconds
Multi-threading: 1.003051996231079 seconds
结果分析：
单线程执行两次I/O操作需要大约2秒。多线程几乎同时执行两个任务，耗时接近1秒，显示了多线程在I/O密集型场景中的优势。
示例三：使用多进程绕过 GIL
如果希望充分利用多核 CPU，可以采用 multiprocessing 模块实现真正的并行处理。
import multiprocessing
import time
# 模拟 CPU 密集型任务
def cpu_bound_task(n):
count = 0
while count < n:
count += 1
# 多进程执行
if __name__ == "__main__":
start_time = time.time()
process1 = multiprocessing.Process(target=cpu_bound_task, args=(10**8,))
process2 = multiprocessing.Process(target=cpu_bound_task, args=(10**8,))
process1.start()
process2.start()
process1.join()
process2.join()
print(f"Multi-processing: {time.time() - start_time} seconds")
输出结果
Multi-processing: 1.930765151977539 seconds
结果分析：
使用多进程，每个进程拥有独立的解释器和 GIL，因此能够真正并行执行。耗时将显著降低（取决于 CPU 核心数量），但需要注意的是，进程间通信会带来额外开销。
示例四：释放GIL与未释放GIL对比
Python中某些库（如numba）， 可释放GIL。以下是一个简单的例子：
import numpy as np
import time
from concurrent.futures import ThreadPoolExecutor
import numba
import multiprocessing
array = np.random.rand(100_000_000) # 1亿个浮点数
# 不释放 GIL 的版本
@numba.jit(nopython=True, nogil=False)
def cpu_bound_gil(data):
total = 0.0
for value in data:
total += value
return total / len(data)
# 释放 GIL 的版本
@numba.jit(nopython=True, nogil=True)
def cpu_bound_nogil(data):
total = 0.0
for value in data:
total += value
return total / len(data)
# 多线程任务
def thread_worker(func, data):
return func(data)
# 多线程测试函数
def run_test(name, func, array_chunks):
start_time = time.perf_counter()
with ThreadPoolExecutor(max_workers=4) as executor:
results = list(executor.map(lambda chunk: thread_worker(func, chunk), array_chunks))
elapsed = time.perf_counter() - start_time
final_mean = sum(results) / len(results)
print(f"{name}: {elapsed:.4f}秒, 结果: {final_mean:.6f}")
return elapsed
if __name__ == "__main__":
print(f"计算1亿个元素的平均值 | CPU核心数: {multiprocessing.cpu_count()}")
# 分块数据
chunks = np.array_split(array, 4)
_ = cpu_bound_gil(array[:1000])
_ = cpu_bound_nogil(array[:1000])
# 执行测试
print("\n--- 开始测试 ---")
gil_time = run_test("未释放 GIL", cpu_bound_gil, chunks)
nogil_time = run_test("已释放 GIL", cpu_bound_nogil, chunks)
# 对比输出
print("\n--- 性能对比 ---")
print(f"释放 GIL 版本速度是未释放版本的 {gil_time / nogil_time:.2f} 倍")
输出结果
计算1亿个元素的平均值 | CPU核心数: 48
--- 开始测试 ---
未释放 GIL: 0.2310秒, 结果: 0.500019
已释放 GIL: 0.0618秒, 结果: 0.500019
--- 性能对比 ---
释放 GIL 版本速度是未释放版本的 3.74 倍
结果分析：
没有了GIL的限制，可实现高效的并行运算。
总结
通过以上代码示例，验证了以下几点：
GIL 对 CPU 密集型任务有明显限制，多线程无法实现真正的并行。多线程适合 I/O 密集型任务，因为线程可以在等待 I/O 时释放 GIL。多进程是绕过 GIL 的有效方法，适用于需要充分利用多核 CPU 的场景。C 扩展模块（如 numba）可以帮助开发者规避 GIL 的限制，提高性能。
参考
一文详解 Python GIL 设计