本文来源公众号“python”，仅用于学术分享，侵权删，干货满满。
原文链接：深入理解Python并发编程中的GIL限制与解决方案
在探讨Python并发编程时，全局解释器锁（Global Interpreter Lock，简称GIL）是一个无法回避的话题。对于许多Python开发者来说，GIL既是一个常见的性能瓶颈，也是一个充满误解的概念。本文将深入探讨GIL的本质、其对并发编程的影响，以及在实际应用中如何有效地克服这一限制。
什么是GIL
全局解释器锁是CPython解释器（Python的官方实现）中的一个机制，它确保同一时刻只有一个线程可以执行Python字节码。简单来说，GIL是一个互斥锁，它保护CPython的内部状态，防止多个线程同时修改Python对象，从而避免潜在的内存损坏和数据不一致问题。
GIL的存在使得Python的内存管理变得相对简单和安全，因为它消除了多线程编程中常见的竞态条件。然而，这种安全性是以牺牲多核CPU并行执行的能力为代价的。当一个Python程序运行在多核处理器上时，尽管操作系统可以将不同的Python线程分配到不同的CPU核心上，但由于GIL的存在，这些线程仍然需要轮流获取GIL才能执行Python代码，导致多线程在CPU密集型任务上无法充分利用多核优势。
以下代码演示了GIL对CPU密集型任务的影响。我们创建一个简单的计算任务，分别使用单线程和多线程方式执行，并比较它们的性能表现。
import time
import threading
def cpu_bound_task(n):
# 一个简单的CPU密集型任务，计算斐波那契数列
if n <= 1:
return n
return cpu_bound_task(n-1) + cpu_bound_task(n-2)
def single_thread():
start = time.time()
cpu_bound_task(35) # 执行一次计算
end = time.time()
return end - start
def multi_thread():
start = time.time()
threads = []
# 创建4个线程，每个线程执行相同的任务
for _ in range(4):
t = threading.Thread(target=cpu_bound_task, args=(35,))
threads.append(t)
t.start()
# 等待所有线程完成
for t in threads:
t.join()
end = time.time()
return end - start
# 测试单线程性能
single_time = single_thread()
print(f"单线程耗时: {single_time:.2f}秒")
# 测试多线程性能
multi_time = multi_thread()
print(f"多线程耗时: {multi_time:.2f}秒")
# 计算多线程相对于单线程的性能比
print(f"多线程/单线程 时间比: {multi_time/single_time:.2f}")
运行以上代码，会发现多线程版本的执行时间可能比单线程版本更长。这是因为线程切换和GIL争用带来的开销，抵消了并行执行的潜在优势。
GIL的局限性
GIL对Python并发编程的影响主要体现在以下几个方面：
-
CPU密集型任务的多线程性能受限。由于GIL的存在，多线程在CPU密集型任务上不仅无法提供性能提升，反而可能因为线程调度和GIL争用导致性能下降。
-
对I/O密集型任务影响较小。当线程执行I/O操作时，Python解释器会释放GIL，允许其他线程执行。因此，对于网络请求、文件读写等I/O密集型任务，多线程仍然能够提供显著的性能提升。
-
并行计算受限。在涉及大量数值计算的科学计算场景下，GIL限制了利用多核CPU进行并行计算的能力。
以下代码对比了GIL在I/O密集型任务中的影响，会发现多线程在这种场景下确实能提供性能改善：
import time
import threading
import requests
def io_bound_task():
# 模拟I/O密集型任务，发起HTTP请求
response = requests.get("https://api.github.com")
return response.status_code
def single_thread_io():
start = time.time()
for _ in range(10):
io_bound_task()
end = time.time()
return end - start
def multi_thread_io():
start = time.time()
threads = []
for _ in range(10):
t = threading.Thread(target=io_bound_task)
threads.append(t)
t.start()
for t in threads:
t.join()
end = time.time()
return end - start
# 测试单线程I/O性能
single_io_time = single_thread_io()
print(f"单线程I/O耗时: {single_io_time:.2f}秒")
# 测试多线程I/O性能
multi_io_time = multi_thread_io()
print(f"多线程I/O耗时: {multi_io_time:.2f}秒")
# 计算性能提升比例
print(f"性能提升: {single_io_time/multi_io_time:.2f}倍")
运行此代码，看到多线程版本相比单线程版本有明显的性能提升，这证明GIL在I/O密集型任务中的影响较小。
三、解决GIL限制的策略
1. 使用多进程替代多线程
Python的multiprocessing模块提供了类似于threading模块的接口，但它使用进程而非线程。每个Python进程都有自己独立的GIL，因此多进程可以有效地绕过GIL限制，充分利用多核CPU的优势。
以下是使用多进程进行并行计算的示例：
import time
import multiprocessing
def cpu_bound_task(n):
# 与前面相同的CPU密集型任务
if n <= 1:
return n
return cpu_bound_task(n-1) + cpu_bound_task(n-2)
def process_worker(n):
# 工作进程执行的任务
return cpu_bound_task(n)
def multi_process():
start = time.time()
# 创建进程池
with multiprocessing.Pool(processes=4) as pool:
# 提交4个任务
results = pool.map(process_worker, [35] * 4)
end = time.time()
return end - start
# 测试多进程性能
process_time = multi_process()
print(f"多进程耗时: {process_time:.2f}秒")
多进程方法的优势在于能够真正实现并行计算，充分利用多核CPU。但它也有一些缺点，如更高的内存开销、进程间通信复杂性以及启动时间较长等。
2. 使用异步编程
Python 3.4+引入了asyncio库，提供了异步编程的支持。异步编程允许在单线程中实现并发，通过在I/O等待期间执行其他任务来提高效率。虽然异步编程不能解决CPU密集型任务的GIL限制，但对于I/O密集型应用，它提供了一种比多线程更轻量级的并发解决方案。
import asyncio
import aiohttp
import time
async def fetch_url(url):
# 异步HTTP请求
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
return await response.text()
async def main():
# 创建多个异步任务
urls = ["https://api.github.com"] * 10
tasks = [fetch_url(url) for url in urls]
# 并发执行所有任务
await asyncio.gather(*tasks)
# 测试异步性能
start = time.time()
asyncio.run(main())
end = time.time()
print(f"异步I/O耗时: {end-start:.2f}秒")
异步编程的优势在于低开销和高效的I/O处理，但它需要特殊的编程模式和支持异步的库。
3. 使用第三方库规避GIL
一些第三方库通过在C扩展中释放GIL来实现高效的并行计算：
-
NumPy和Pandas: 这些库的许多数值计算函数在C语言层面实现，在执行计算时会释放GIL，允许其他Python线程并行执行。
-
Cython: 通过将Python代码转换为C扩展，可以在性能关键的部分手动释放GIL，实现真正的多线程并行。
-
Numba: 提供了即时编译(JIT)功能，可以将Python函数编译为优化的机器码，并支持在编译后的函数中释放GIL。
以下是使用Numba规避GIL的示例：
import numba
import time
import threading
@numba.jit(nopython=True, nogil=True)
def cpu_heavy_task(n):
# 一个CPU密集型任务
sum_val = 0
for i in range(n):
sum_val += i * i
return sum_val
def run_parallel():
start = time.time()
threads = []
for _ in range(4):
t = threading.Thread(target=cpu_heavy_task, args=(100000000,))
threads.append(t)
t.start()
for t in threads:
t.join()
end = time.time()
return end - start
# 测试Numba多线程性能
numba_time = run_parallel()
print(f"Numba多线程耗时: {numba_time:.2f}秒")
# 对比不使用Numba的版本
def regular_cpu_task(n):
sum_val = 0
for i in range(n):
sum_val += i * i
return sum_val
def run_regular_parallel():
start = time.time()
threads = []
for _ in range(4):
t = threading.Thread(target=regular_cpu_task, args=(100000000,))
threads.append(t)
t.start()
for t in threads:
t.join()
end = time.time()
return end - start
regular_time = run_regular_parallel()
print(f"普通多线程耗时: {regular_time:.2f}秒")
print(f"性能提升: {regular_time/numba_time:.2f}倍")
通过Numba的nogil=True选项，我们可以在编译后的函数执行期间释放GIL，从而实现真正的并行执行。
4. 使用替代Python解释器
-
PyPy: 虽然PyPy也有GIL，但其JIT编译器可以提供更好的性能。
-
Jython: 在JVM上运行的Python实现，没有GIL。
-
IronPython: 在.NET平台上运行的Python实现，也没有GIL。
实际应用中的选择策略
-
任务类型: 对于CPU密集型任务，多进程或C扩展是更好的选择；对于I/O密集型任务，多线程或异步编程通常足够高效。
-
开发复杂度: 多线程开发相对简单，多进程需要考虑进程间通信，而异步编程则需要特殊的编程范式。
-
资源消耗: 多进程消耗更多内存，多线程共享内存但有GIL限制，异步编程则是轻量级的单线程并发。
-
性能要求: 对于高性能计算，可能需要使用Cython或Numba等工具规避GIL；对于一般应用，Python内置的并发工具通常已足够。
在大多数情况下，一个实用的策略是根据任务特性混合使用不同的并发方式。例如，可以使用多进程处理CPU密集型计算，同时在每个进程内使用异步编程处理I/O操作，这样既能绕过GIL限制，又能高效处理I/O任务。
总结
Python的GIL确实给并发编程带来了一定的限制，特别是在CPU密集型任务的并行处理上。通过理解GIL的本质和局限性，可以采用多种策略来有效规避这些限制。对于I/O密集型应用，多线程和异步编程仍然是高效的解决方案；对于CPU密集型任务，多进程、C扩展、Numba等工具提供了绕过GIL实现真正并行的方法。
THE END !
文章结束，感谢阅读。您的点赞，收藏，评论是我继续更新的动力。大家有推荐的公众号可以评论区留言，共同学习，一起进步。
扫一扫
269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
