Python高级技术之：`GIL`对多核`CPU`的利用率：从源码层面看`GIL`的释放时机。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位观众，大家好！今天咱们聊聊Python里那个让人又爱又恨的家伙——GIL，也就是全局解释器锁 (Global Interpreter Lock)。别看它名字挺唬人，其实简单说，就是个“锁”，锁住了Python解释器，让同一时刻只能有一个线程执行Python字节码。

很多人一听GIL就皱眉头，觉得它限制了Python在多核CPU上的发挥。那今天咱们就来扒一扒GIL的底裤，从源码层面看看它到底是怎么运作的，以及它什么时候会“放权”，让其他线程也喘口气。

一、GIL是个什么玩意儿？

首先，得明确一点：GIL不是Python语言本身的特性，而是CPython解释器（也是最常用的Python解释器）的实现细节。其他的Python解释器，比如Jython、IronPython，就没有GIL这个东西。

GIL的存在，主要是为了简化CPython解释器的内存管理，特别是线程安全相关的部分。没有GIL，就得用更复杂的锁机制来保护共享资源，这会带来额外的性能开销，甚至死锁的风险。

你可以把GIL想象成一个厕所的门锁。就算你家有十个厕所，每次也只能有一个人进去拉屎。别人必须等着，直到里面的人出来，才能进去。这样能保证厕所里的卫生纸不会被抢光，马桶也不会同时被几个人挤爆。

二、GIL如何影响多核CPU的利用率？

因为GIL的存在，即使你的机器有8个核，Python的多线程程序也只能在一个核上跑。其他的核只能眼巴巴地看着，无所事事。这就导致了Python在CPU密集型任务上的性能瓶颈。

举个例子，假设你有一个计算密集型的任务，需要对一个很大的列表进行复杂的数学运算。如果你用多线程来加速这个任务，实际上并不会快多少，因为GIL会让所有的线程排队执行，只有一个线程能真正利用CPU。

三、GIL的释放时机：源码剖析

好，现在咱们来点硬货，看看GIL到底在什么时候会释放，给其他线程一个机会。这部分需要稍微了解一下CPython的源码，不过别担心，我会尽量用通俗易懂的方式来讲解。

CPython的解释器有一个主循环，叫做PyEval_EvalFrameEx。这个函数负责执行Python的字节码。 GIL的释放和获取，就发生在这个主循环里。

简单来说，GIL会在以下几种情况下释放：

I/O操作： 当一个线程执行I/O操作（比如读写文件、网络请求）时，GIL会被释放，让其他线程有机会执行。因为I/O操作通常比较耗时，释放GIL可以让其他线程在等待I/O完成的时候做一些有用的事情。
时间片轮转： CPython解释器会定期检查当前线程的执行时间。如果一个线程执行的时间超过了一个预设的阈值（通常是5毫秒），GIL会被释放，让其他线程有机会执行。这种机制叫做时间片轮转。
显式释放： 有些Python扩展库（比如NumPy）会显式地释放GIL，以便利用多核CPU进行并行计算。这些扩展库通常是用C或C++编写的，可以直接操作底层硬件，不需要依赖GIL。

咱们来用代码模拟一下GIL的释放时机：

import threading
import time

def cpu_bound(number):
    """模拟CPU密集型任务"""
    start = time.time()
    while time.time() - start < 1: # 运行1秒
        number * number
    print(f"CPU bound task finished in thread {threading.current_thread().name}")

def io_bound():
    """模拟I/O密集型任务"""
    time.sleep(1) # 模拟耗时1秒的I/O操作
    print(f"IO bound task finished in thread {threading.current_thread().name}")

if __name__ == '__main__':
    start = time.time()

    cpu_thread1 = threading.Thread(target=cpu_bound, args=(10000000,), name="CPU-Thread-1")
    cpu_thread2 = threading.Thread(target=cpu_bound, args=(20000000,), name="CPU-Thread-2")
    io_thread = threading.Thread(target=io_bound, name="IO-Thread")

    cpu_thread1.start()
    cpu_thread2.start()
    io_thread.start()

    cpu_thread1.join()
    cpu_thread2.join()
    io_thread.join()

    end = time.time()
    print(f"Total time: {end - start:.4f} seconds")

在这个例子中，cpu_bound 函数模拟了一个CPU密集型任务，io_bound 函数模拟了一个I/O密集型任务。我们可以看到，即使有两个CPU密集型线程同时运行，它们的执行时间也几乎是串行的，因为GIL的存在。而I/O密集型线程的执行时间，则不会受到GIL的太大影响，因为它在等待I/O完成的时候会释放GIL。

四、深入源码：PyEval_EvalFrameEx

想要更深入地了解GIL的释放时机，我们需要看看CPython的源码。这里我们主要关注PyEval_EvalFrameEx函数，它是Python解释器的核心。

// 简化后的PyEval_EvalFrameEx函数
PyObject *
PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
{
    // ... 省略一些代码

    for (;;) {
        // ... 省略一些代码

        // 获取字节码
        opcode = *next_instr++;

        // 根据字节码执行不同的操作
        switch (opcode) {
            // ... 省略一些字节码的处理

            case CALL_FUNCTION: {
                // ...
                // 调用函数
                result = PyEval_CallObjectWithKeywords(func, args, kw);
                // ...
                break;
            }

            // ... 省略其他字节码的处理
        }

        // ... 省略一些代码

        // 检查是否需要释放GIL
        if (--_Py_Ticker < 0) {
            // 定期释放GIL
            _Py_Ticker = CHECK_INTERVAL;

            /* Give another thread a chance */
            PyThreadState_Release(tstate); // 释放GIL
            PyThreadState_Acquire(tstate); // 重新获取GIL
        }

        // ... 省略一些代码
    }

    // ... 省略一些代码
}

在上面的代码中，我们可以看到，PyEval_EvalFrameEx函数在一个无限循环中执行Python字节码。在每次循环中，它会检查_Py_Ticker的值。如果_Py_Ticker的值小于0，就说明当前线程已经执行了一段时间，需要释放GIL，让其他线程有机会执行。

CHECK_INTERVAL是一个常量，定义了时间片的长度。在CPython 3.2之后，CHECK_INTERVAL的值是100，这意味着每执行100条字节码，就会检查一次是否需要释放GIL。这个值可以通过sys.setcheckinterval()函数来修改。

五、GIL的替代方案

既然GIL有这么多缺点，那有没有什么替代方案呢？当然有。

多进程： 使用multiprocessing模块，可以创建多个进程，每个进程都有自己的Python解释器和GIL。这样就可以充分利用多核CPU的性能。但是，多进程之间的通信比较复杂，需要使用管道、队列等机制。
使用没有GIL的Python解释器： 比如Jython和IronPython。但是，这些解释器的生态系统不如CPython完善，有些Python库可能无法使用。
使用C扩展： 将CPU密集型的任务用C或C++编写，然后通过Python的C扩展接口来调用。 C扩展可以直接操作底层硬件，不需要依赖GIL。 NumPy就是这样做的。
异步编程： 使用asyncio模块，可以将I/O密集型的任务异步化。异步编程可以避免线程阻塞，提高程序的并发性能。但是，异步编程需要使用特殊的语法和库，学习成本较高。

下表总结了这些替代方案的优缺点：

方案	优点	缺点	适用场景
多进程	充分利用多核CPU，每个进程都有自己的GIL，互不干扰。	进程间通信复杂，需要使用管道、队列等机制。内存占用较大，每个进程都需要复制一份数据。	CPU密集型任务，需要充分利用多核CPU，且进程间通信不太频繁。
无GIL解释器	没有GIL的限制，可以充分利用多核CPU。	生态系统不如CPython完善，有些Python库可能无法使用。	对性能要求极高，必须充分利用多核CPU，且可以接受生态系统不完善的缺点。
C扩展	可以直接操作底层硬件，不需要依赖GIL。性能高，可以充分利用多核CPU。	开发成本高，需要熟悉C/C++语言和Python的C扩展接口。调试困难，容易出现内存泄漏等问题。	CPU密集型任务，需要极致的性能，且有C/C++开发经验。
异步编程	可以避免线程阻塞，提高程序的并发性能。资源占用少，不需要创建大量的线程或进程。	学习成本高，需要使用特殊的语法和库。调试困难，容易出现回调地狱等问题。	I/O密集型任务，需要高并发，且可以接受异步编程的学习成本。

六、总结

GIL是CPython解释器的一个历史遗留问题，它限制了Python在多核CPU上的发挥。但是，GIL并不是一无是处。它简化了CPython解释器的内存管理，提高了单线程程序的性能。

想要充分利用多核CPU的性能，可以考虑使用多进程、无GIL的Python解释器、C扩展或异步编程等替代方案。选择哪种方案，取决于具体的应用场景和需求。

记住，没有银弹。选择最适合你的工具，才能发挥最大的效用。

好了，今天的讲座就到这里。希望大家对GIL有了更深入的了解。下次再见！

发表回复 取消回复

发表回复取消回复