MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python全局解释器锁(GIL)机制

2022-12-022.3k 阅读

Python全局解释器锁(GIL)机制概述

Python作为一门广泛应用的编程语言，其设计中包含了一个重要的机制——全局解释器锁（Global Interpreter Lock，简称GIL）。GIL是Python解释器中的一把互斥锁，它的主要作用是在任何时刻，只允许一个线程在Python解释器中执行字节码。这意味着，尽管Python提供了多线程编程的支持，但在多核CPU环境下，Python多线程并不能充分利用多核的优势来提升计算密集型任务的执行效率。

从Python解释器的架构来看，它是基于栈的虚拟机，执行字节码指令。在这个过程中，GIL的存在确保了Python对象模型的一致性和内存管理的安全性。因为Python的对象模型并非线程安全的，如果没有GIL，多个线程同时访问和修改Python对象可能会导致数据竞争和未定义行为。例如，在Python中创建一个列表对象，并在多个线程中同时对其进行添加和删除元素的操作，如果没有适当的同步机制，很可能会导致列表内部结构的损坏。

GIL在不同Python实现中的情况

CPython中的GIL

CPython是最广泛使用的Python解释器实现，也是默认的Python版本。在CPython中，GIL是实现Python多线程的基础机制。CPython的内存管理是非线程安全的，为了避免多个线程同时进行内存操作导致的内存损坏等问题，GIL被引入。当一个线程想要执行Python字节码时，它必须先获取GIL。只有持有GIL的线程才能执行字节码指令，并且在执行完一定数量的字节码指令（具体数量由 sys.getcheckinterval() 函数获取，默认通常为100）或者遇到I/O操作等情况时，线程会释放GIL，让其他线程有机会获取GIL并执行。

Jython与IronPython的情况

与CPython不同，Jython（Python在Java平台上的实现）和IronPython（Python在.NET平台上的实现）并没有GIL。这是因为它们借助了底层平台（Java虚拟机和.NET框架）的线程管理和内存管理机制。Jython利用Java的线程模型和内存管理，Java的线程安全机制可以有效地保证多线程环境下的安全操作。同样，IronPython依赖于.NET框架的线程和内存管理，使得它不需要像CPython那样通过GIL来保证对象模型的一致性和内存安全。

GIL对多线程编程的影响

计算密集型任务的困境

对于计算密集型任务，例如进行大量的数学运算、图像渲染等，Python多线程由于GIL的存在，并不能充分利用多核CPU的优势。假设有一个简单的计算任务，计算1到100000000的整数之和：

import threading


def sum_numbers():
    total = 0
    for i in range(1, 100000001):
        total += i
    return total


threads = []
for _ in range(4):
    t = threading.Thread(target=sum_numbers)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

在上述代码中，我们创建了4个线程来执行相同的计算任务。然而，由于GIL的存在，这些线程实际上是串行执行的，每个线程在执行时需要获取GIL，并且在执行完一定字节码指令后释放GIL，所以并没有真正利用多核CPU并行计算，整体执行时间可能比单线程执行并没有显著提升，甚至可能因为线程切换的开销而略有增加。

I/O密集型任务的优势

虽然GIL限制了计算密集型任务的多线程并行执行，但在I/O密集型任务中，Python多线程却能发挥一定的优势。I/O操作（如文件读写、网络请求等）通常需要等待外部设备的响应，这个过程中线程会释放GIL。例如，在进行网络请求时，线程发起请求后，在等待服务器响应的过程中会释放GIL，此时其他线程就有机会获取GIL并执行。以下是一个简单的文件读取示例：

import threading


def read_file(file_path):
    with open(file_path, 'r') as f:
        data = f.read()
    return data


file_paths = ['file1.txt', 'file2.txt', 'file3.txt', 'file4.txt']
threads = []
for path in file_paths:
    t = threading.Thread(target=read_file, args=(path,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

在这个示例中，每个线程在进行文件读取时，由于I/O操作会释放GIL，其他线程可以利用这段时间获取GIL并执行自己的文件读取操作，从而提高整体的I/O操作效率。

GIL的实现原理

GIL的获取与释放

在CPython中，线程在执行字节码之前必须获取GIL。这一过程通过 PyEval_AcquireLock 函数实现。当线程成功获取GIL后，它才能开始执行字节码指令。在执行过程中，线程会定期检查是否需要释放GIL。具体来说，CPython会在执行一定数量的字节码指令后检查，这个数量可以通过 sys.setswitchinterval() 函数进行设置（不过通常不建议随意修改，因为这可能会影响Python解释器的性能和稳定性）。当满足释放条件时，线程会调用 PyEval_ReleaseLock 函数释放GIL，让其他线程有机会获取。

GIL与线程调度

GIL与操作系统的线程调度机制密切相关。在CPython中，虽然GIL限制了同一时间只有一个线程执行字节码，但操作系统的线程调度器仍然会调度Python线程。当一个线程获取GIL并开始执行后，操作系统可能会根据其调度策略（如时间片轮转等）暂停该线程的执行。在这种情况下，线程会自动释放GIL，以便其他线程可以获取并执行。当被暂停的线程再次被调度执行时，它需要重新获取GIL才能继续执行字节码。

绕过GIL的方法

使用多进程

多进程是绕过GIL限制的有效方法之一。Python的 multiprocessing 模块提供了多进程编程的支持。每个进程都有自己独立的Python解释器实例和内存空间，因此不存在GIL的问题。例如，对于前面计算密集型任务的例子，可以使用多进程进行优化：

import multiprocessing


def sum_numbers():
    total = 0
    for i in range(1, 100000001):
        total += i
    return total


if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    results = pool.map(sum_numbers, [])
    pool.close()
    pool.join()

在上述代码中，通过 multiprocessing.Pool 创建了一个包含4个进程的进程池，每个进程独立执行 sum_numbers 函数。由于每个进程有自己的Python解释器和内存空间，它们可以真正地并行执行，充分利用多核CPU的优势，大大提高计算密集型任务的执行效率。需要注意的是，在Windows系统下，由于其进程创建方式的特殊性，需要将相关代码放在 if __name__ == '__main__': 块中，以避免一些启动问题。

使用C扩展模块

另一种绕过GIL的方法是使用C扩展模块。通过编写C语言代码，并将其封装为Python的扩展模块，可以在执行C代码时释放GIL。CPython提供了 Py_BEGIN_ALLOW_THREADS 和 Py_END_ALLOW_THREADS 宏来实现这一功能。在C代码块中使用这两个宏，当进入 Py_BEGIN_ALLOW_THREADS 标记的代码段时，GIL会被释放，其他线程可以在这段时间内执行。当代码执行到 Py_END_ALLOW_THREADS 时，GIL会被重新获取。以下是一个简单的C扩展模块示例，用于计算两个整数的和：

#include <Python.h>

static PyObject* add_numbers(PyObject* self, PyObject* args) {
    int num1, num2;
    if (!PyArg_ParseTuple(args, "ii", &num1, &num2)) {
        return NULL;
    }
    Py_BEGIN_ALLOW_THREADS
    int result = num1 + num2;
    Py_END_ALLOW_THREADS
    return PyLong_FromLong(result);
}

static PyMethodDef ExampleMethods[] = {
    {"add_numbers", add_numbers, METH_VARARGS, "Add two numbers."},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef examplemodule = {
    PyModuleDef_HEAD_INIT,
    "example",
    "Example module",
    -1,
    ExampleMethods
};

PyMODINIT_FUNC PyInit_example(void) {
    return PyModule_Create(&examplemodule);
}

然后可以通过 setuptools 等工具将上述C代码编译为Python扩展模块，并在Python中使用：

import example


result = example.add_numbers(3, 5)
print(result)

通过这种方式，在执行C代码部分时可以释放GIL，提高多线程环境下的执行效率，尤其适用于对性能要求较高的计算密集型任务。

使用异步编程

异步编程也是应对GIL的一种有效方式，特别是在处理I/O密集型任务时。Python的 asyncio 库提供了异步编程的支持。异步编程通过事件循环来管理任务的执行，在I/O操作时不会阻塞线程，而是将控制权交回给事件循环，让其他任务有机会执行。例如，以下是一个简单的异步网络请求示例：

import aiohttp
import asyncio


async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()


async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, 'http://example.com'), fetch(session, 'http://another-example.com')]
        results = await asyncio.gather(*tasks)
        print(results)


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

在上述代码中，fetch 函数使用 async 和 await 关键字定义为异步函数。在执行网络请求时，await 语句会暂停当前函数的执行，将控制权交回给事件循环，让其他异步任务可以执行。这样，即使在单线程环境下，也能高效地处理多个I/O操作，避免了GIL对I/O密集型任务的限制。

GIL的未来发展

可能的改进方向

随着硬件技术的不断发展，多核CPU的普及使得充分利用多核性能变得越来越重要。Python社区也在不断探讨GIL的改进方向。一种可能的改进是对CPython的内存管理进行改造，使其变得线程安全，从而减少对GIL的依赖。这样在多线程环境下，线程可以更自由地访问和修改Python对象，提高计算密集型任务的并行执行能力。另一个方向是进一步优化GIL的获取和释放机制，例如根据任务的类型（计算密集型或I/O密集型）动态调整GIL的持有时间，以提高整体性能。

对Python生态的影响

如果GIL得到改进或去除，将对Python生态产生深远影响。对于计算密集型应用，如科学计算、数据分析等领域，Python的性能将得到显著提升，可能会吸引更多对性能要求苛刻的用户和开发者。同时，多线程编程在Python中将变得更加高效和直观，这可能会促使更多开发者采用多线程方式编写代码。然而，任何对GIL的重大改变都需要谨慎进行，因为这可能会影响现有的大量Python代码和库的兼容性，需要Python社区进行全面的测试和调整。

综上所述，虽然GIL在一定程度上限制了Python多线程在计算密集型任务中的性能，但通过合理的编程方式，如使用多进程、C扩展模块和异步编程等，可以有效地绕过GIL的限制，发挥Python在不同场景下的优势。同时，Python社区也在持续探索GIL的改进方向，以进一步提升Python在多线程和多核环境下的性能表现。