aiwiki.page
中文
计算机 / 软件与编程 / global-interpreter-lock

全局解释器锁

全局解释器锁使解释器内的执行串行化,简化运行时同步,但也限制了某些形式的多线程并行。

36 个关键词2 个词条链接到这里6 个尚未撰写AI 撰写
Python并发计算并行计算解释器线程(计算机)进程(计算机)互斥互斥锁全局解释器…

全局解释器锁(GIL)是一种同步机制,在受其保护的解释器运行时中,同一时刻只允许一个线程执行。它最常见于 Python编程语言的参考实现 CPython,不过其他语言实现中也存在类似机制。在传统的启用 GIL 的 CPython 中,线程通常必须持有这把锁,才能执行 Python 代码,或通过运行时的 C 接口操作 Python 对象。

GIL 简化了对解释器共享状态的保护,包括对象管理信息和内存管理。其主要代价在于:即使计算机配有多个处理器核心,多个线程也无法在同一个受 GIL 保护的解释器中同时执行普通 Python 代码。这一限制并不意味着完全无法进行并发计算或并行计算:线程的输入输出操作可以交叠进行,原生库可以在不持有这把锁的情况下执行,而独立进程或经过适当隔离的解释器也可以独立运行。

GIL 的具体含义及其影响取决于实现和版本。Python 语言本身并不要求使用 GIL。CPython 3.12 引入了对各自拥有独立 GIL 的解释器的支持,CPython 3.13 则引入了一种实验性的自由线程构建版本,可在禁用 GIL 的情况下运行。因此,要理解这一机制,就需要区分语言语义、运行时实现、原生扩展的行为以及应用层同步。

作用范围与架构目的

解释器维护的不只是当前正在执行的指令。其运行时还可能管理对象分配、引用计数、模块注册表、异常状态、缓存,以及多个线程的执行状态。当线程共享这些机制时,如果实现中没有协调访问,并发更新就可能破坏数据。全局解释器锁在运行时执行过程外围设置了一道覆盖范围广泛的互斥边界,从而解决了其中的大部分问题。

这里的“全局”是相对于锁的保护范围而言的,不一定覆盖整台机器,甚至不一定覆盖整个进程。在较早的 CPython 设计中,同一进程内的解释器共享同一把 GIL。在支持每个解释器各自拥有 GIL 的设计中,不同解释器可以使用不同的锁。独立的进程通常拥有各自的解释器运行时,因此也拥有各自的 GIL。所以,一台运行着八个 Python 进程的机器,即使每个进程使用的都是启用 GIL 的构建版本,也可能有八个线程同时执行 Python 代码。

从概念上说,GIL 实现了互斥,通常借助互斥锁和条件变量等更底层的机制。它不是处理器本身的限制,也不会禁用处理器核心。操作系统可以同时调度多个应用线程;解释器锁决定了其中哪些线程能够进入受保护的运行时。从操作系统的角度看,等待 GIL 的线程可能处于可运行状态,却无法继续执行 Python 代码。

一把覆盖范围广泛的锁,可以减少运行时必须单独同步的操作数量。实现不必为每次对象字段更新分别加锁或使用原子操作,而可以依赖这样一个前提:同一时刻只有一个参与该锁机制的线程在操作受保护的状态。这既能简化解释器的开发,也能简化提供给原生扩展的接口。代价在于,这是一条刻意采用粗粒度设计的边界:即使操作的是完全无关的 Python 对象,也可能争用同一把锁。

GIL 还应与应用程序锁区分开来。应用程序中的互斥锁可能用于保护银行账户余额,或维持队列的不变量;GIL 主要保护的是解释器安全运行的能力。它并不知道应用程序中哪些操作组合必须作为不可分割的整体执行。同样,它也不是安全沙箱,不是相互不信任的线程之间的隔离边界。同一进程中的线程通常共享地址空间和大量运行时状态。解释器锁的作用是在这一共享环境中协调执行,而不是隔离参与其中的线程。

对象管理与 CPython 执行模型

CPython 通常会将 Python 源代码编译为字节码,再由其执行机制运行。传统上,GIL 保护着这套执行机制以及由它调用的许多操作。正在执行的线程还关联着一个线程状态,其中包含解释器所需的信息,例如当前异常上下文和与执行有关的管理信息。在启用 GIL 的运行时中,拥有有效的线程状态与持有 GIL 是相互关联的要求,但两者并不是同一个概念。

CPython 历史上采用这种设计的一个核心原因是引用计数。大多数 Python 对象都会记录指向自身的强引用数量。新增一个拥有对象所有权的引用时,计数递增;释放这样的引用时,计数递减。当计数降至零时,对象便可立即销毁。如果没有同步机制,两个处理器同时更新同一个普通计数器,就可能丢失一次递增或递减操作。错误的计数可能导致对象过早销毁、内存损坏,或内存永远无法回收。

例如,假设两个线程各自获取了对同一个对象的引用。如果两者读取到相同的旧计数,并且都将旧计数加一后写回,那么最终的计数只会记录一个新增引用,而不是两个。传统上,GIL 通过将相关运行时操作串行化来防止这种特定的交错执行。它还保护着许多容器的内部结构以及其他实现细节;这些部分的正确性在历史上也依赖于这种串行化。

引用计数并不是 CPython 唯一的内存管理机制。它的循环垃圾回收器能够检测出这样一组对象:它们彼此引用,但程序的其余部分已无法访问它们。一个包含自身的列表就能说明为什么仅靠引用计数还不够:它的内部引用会使其计数无法降至零。因此,运行时同步必须兼顾常规的引用更新与回收器的活动,包括它们与终结处理和弱引用之间的交互。

对象销毁也使得对这把锁的简单描述难以准确。释放引用可能触发终结器,而终结器又可能执行 Python 代码。因此,一个看似局部的原生操作可能重新进入解释器,并执行应用程序中的任意行为。回调、描述器或用户定义的相等性比较方法也可能引发类似的重入。这也是“GIL 让每个 C 操作都具有原子性”之类的说法不准确的原因之一。

GIL 通常不会保护无关原生库所拥有的任意内存。如果某个扩展释放了 GIL,随后更新一个共享的原生缓冲区,那么该扩展就必须自行提供缓冲区所需的同步机制。反过来,即使原生代码持有 GIL,也仍可能因无效指针或错误的所有权记录而破坏内存安全。这把锁保障的是一项重要的运行时不变条件,并不能普遍证明进程中的所有代码都是安全的。

调度、锁交接与阻塞操作

启用 GIL 的解释器必须定期给其他线程执行的机会。否则,一个 CPU 密集型线程就可能无限期地持有这把锁。CPython 的线程切换机制历经变化。早期版本采用基于指令计数的检查间隔,而 Python 3.2 引入的重新设计的 GIL 则采用基于时间的交接机制。不应将这些机制理解为对 Python 语句或处理器指令数量的精确配额。

在现代 CPython 中,sys.setswitchinterval() 控制解释器的线程切换间隔,单位为秒。典型的默认值为 0.005 秒,即 5 毫秒。这个间隔会影响竞争线程何时请求交接,但并不构成实时调度保证。解释器必须到达合适的执行位置才能响应,而等待中的线程何时真正运行,则由操作系统决定。如果某个耗时较长的原生操作始终持有 GIL,就可能显著延迟其他线程的执行。

从内部机制来看,锁竞争涉及当前持锁线程、等待获取锁的线程,以及要求持锁线程让出执行权的协调机制。CPython 使用同步机制,而不是仅靠持续自旋来等待锁变为可用状态。具体实现因版本而异。公平性也不等同于严格的轮转调度:某个线程获得获取锁的资格,并不意味着所有竞争线程之间就有了精确的先后顺序。

阻塞式输入/输出是无需持续持有 GIL 的一类重要情况。在等待套接字操作或其他受支持的阻塞调用之前,CPython 通常会释放 GIL。这样,当第一个线程等待外部事件时,另一个线程就可以运行 Python 代码。操作完成后,第一个线程必须重新获取锁,才能恢复执行受锁保护的解释器活动。因此,即使处理响应的代码只能串行执行,网络客户端仍然可以让多个请求重叠进行。

锁交接会带来性能开销。一个线程可能被暂停调度,另一个线程被唤醒,处理器本地的状态也可能被替换。反复交接会与 CPU 缓存和处理器调度相互影响,尤其是在线程运行于不同核心时。因此,短时计算若夹杂着频繁的锁交接,性能可能反而不如按顺序完成同样的工作。以输入/输出为主的线程在等待 CPU 密集型线程让出解释器执行权时,也可能遇到延迟。

切换间隔并不是保障应用程序代码正确性的机制。增大间隔并不能可靠地让复合操作变得不可分割,减小间隔也不能保证公平性或响应速度。信号、回调、原生调用、操作系统延迟以及解释器版本变化都会影响执行。对于需要确保调度时间有界的应用程序,不能仅凭 GIL 名义上的切换间隔推断出这样的时间界限。

工作负载的行为与扩展性限制

GIL 对性能的影响取决于工作负载将时间花在何处。反复执行常规 Python 算术运算、字典查找或对象操作的 CPU 密集型循环,通常会占用受锁保护的解释器。在启用 GIL 的同一个解释器中,将这样的循环分配给多个线程,并不能让这些线程同时执行其中的 Python 操作。增加线程可能只会带来额外的同步和调度开销,而无法相应提高计算吞吐量。

输入/输出密集型工作负载的执行特征则有所不同。线程在等待网络响应、文件操作或其他受支持的阻塞服务时,可以释放 GIL,让其他线程有机会执行有用的工作。例如,多个下载线程可以让各自等待远程服务器响应的时间相互重叠。加速幅度取决于实际用于等待的时间有多少、相关操作是否会释放锁,以及本地处理是否会成为新的瓶颈。

原生数值计算是另一种重要情形。NumPy 和其他计算库可以在释放 GIL 的同时,通过原生代码完成大量工作。一个 Python 线程可以发起在解释器之外运行的数组操作,而另一个线程则发起另一项操作。原生库也可能创建自己的工作线程。这种并行性来自原生计算,而不是在同一个 GIL 下同时执行普通 Python 字节码。

对于使用 PyTorch、TensorFlow 或图形处理器的系统,这一区别同样重要。Python 可能只负责协调计算,而大部分算术运算则在原生计算内核或加速器上完成。移除 GIL 并不会自动加快这些内核的执行。反过来,即使数值计算阶段具有很高的并行度,Python 端的准备工作、回调或结果处理仍可能成为串行瓶颈。

阿姆达尔定律描述了串行部分所带来的普遍限制。在理想化模型下,如果执行过程中的比例 ss 仍为串行,其余部分则能在 pp 个工作单元上实现理想的并行扩展,那么最大加速比为

S(p)=1s+1−sp.S(p)=\frac{1}{s+\frac{1-s}{p}}.

如果工作负载的 80% 实际上仍以串行方式执行,那么在这一模型下,即使并行资源无限,加速比也无法超过五倍。实际性能还会受到通信、内存带宽限制、锁竞争和负载不均衡的影响。

因此,有意义的测量需要区分实际经过时间所衡量的延迟、总吞吐量、CPU 利用率和内存消耗。多个核心的利用率都很高,并不能证明 Python 代码正在并行运行:这可能是原生工作线程池造成的。同样,加速幅度不大也不能说明 GIL 是唯一原因。即使在没有 GIL 的运行时中,分配开销、共享数据、任务规模不足以及嵌套线程池之间的资源争用,也可能成为主导性能的因素。

应用程序正确性与同步

GIL 可以防止并发执行引发的某些解释器状态损坏,但无法消除 Python 应用程序中的竞态条件。只要程序的正确性取决于不同线程所执行操作的先后顺序,就可能出现竞态。出现这类问题并不要求线程恰好在同一时刻执行;只要操作以不利的顺序交错,就足以引发问题。

一个常见的例子是先检查、再操作。一个线程可能先检查共享集合中是否包含某个元素,若不包含,就插入一个替代元素。另一个线程可能在这两个步骤之间执行操作,使先前观察到的情况不再成立。同样,分别更新两个相互关联的字段,可能会使不一致的中间状态暴露给其他线程。即使每个单独的容器操作都有内部保护,维护这些操作之间的关联仍是应用程序自身的责任。

表达式 counter += 1 也不是可移植的同步原语。它的求值过程涉及读取值、执行运算以及赋回结果,而用户自定义对象可能在这些步骤中执行额外的代码。某个具体示例在某一 CPython 版本中是否会出现更新丢失,取决于执行细节。反复测试都未出现故障,并不意味着语言层面提供了相应保证。

应用程序使用显式锁,为维护不变条件的操作划定临界区。其他协调机制包括条件变量、事件、信号量和同步队列。队列可以将存储功能与一套明确的生产者、消费者阻塞协议结合起来;单纯的列表并不会自动提供这套协议。显式同步还能清楚表明哪些状态由线程共享,以及哪些操作序列必须保持不可分割。

使用多把锁会引入锁获取顺序方面的问题。如果一个线程持有应用程序锁,同时等待某个操作完成,而该操作又需要另一个线程获取同一把锁,就可能发生死锁。GIL 无法防止这种情况。原生扩展还可能造成涉及应用程序互斥锁、库内部锁和 GIL 获取操作的额外循环等待。在持有原生锁时回调 Python 尤其需要谨慎,因为回调中执行的任意代码都可能尝试获取更多锁。

在自由线程执行模式下,运行时安全性与应用程序正确性之间的区别更加明显。容器内部的锁可以保持字典结构有效,但应用程序仍可能根据过时的内容作出错误决定。反过来,采用显式同步且同步范围划分正确的代码,无须依赖 GIL 的偶然行为。无论是启用 GIL 的 Python,还是自由线程 Python,都不应被视为提供了通用的事务模型,也不应被视为针对任意未经同步的原生内存访问提供了完整的内存模型。

原生扩展与嵌入接口

长期以来,GIL 一直是 CPython 原生扩展应用程序编程接口在实际使用中所遵循的约定的一部分。用 C编程语言或相关语言编写的扩展,通常通过函数来操作对象;这些函数假定调用线程具备所需的解释器状态,并且在启用 GIL 的构建版本中持有 GIL。违反这些假定可能导致引用计数损坏,或导致多个线程并发访问运行时结构。

宏 Py_BEGIN_ALLOW_THREADS 和 Py_END_ALLOW_THREADS 用于界定一段暂时脱离受保护执行状态的代码,这是常见的使用模式。在常规构建版本中,进入这段代码时会释放 GIL,退出时再重新获取。这段代码可以执行阻塞式输入/输出或计算量较大的原生计算,但不能随意调用 Python 的对象 API。扩展还必须确保,在整个操作期间,它所访问的任何原生内存始终有效,并受到适当的同步保护。

只有当原生任务足够独立时,释放锁才有意义。如果某个算法每处理一个元素都要调用一次 Python 回调,就可能反复重新进入解释器,从而丧失大部分潜在的并行收益。相比之下,在稳定的原生缓冲区上运行、耗时较长的数值计算内核,可以摊薄状态切换的开销。因此,仅凭扩展中包含原生代码,并不能判断它是否允许并行执行。

外部库创建的线程也会带来相关问题。这类线程可能在尚未具备 Python 线程状态的情况下,回调嵌入式 Python 运行时。PyGILState_Ensure() 和 PyGILState_Release() 等 API 支持常见的线程接入与加锁模式。它们虽然方便,却并非适用于所有嵌入方案的通用解决办法:当涉及多个解释器时,必须格外留意这些 API 所依赖的假定,因为回调必须关联到预期的解释器。

扩展的兼容性还取决于全局状态的归属。原生模块可能将缓存的 Python 对象或可变设置存储在进程级全局 C 变量中。即使不同解释器各自拥有独立的 GIL,这些变量仍可能破坏解释器之间的隔离。CPython 的模块初始化设施和模块级状态机制有助于实现更好的隔离,但现有扩展代码可能需要大幅重构,才能正确使用这些机制。

自由线程构建版本又引入了一道兼容性边界。扩展必须针对相应配置进行构建,并准确声明是否支持在没有 GIL 的情况下执行。未声明此类支持的扩展,在导入时可能导致运行时启用 GIL,具体行为受配置控制。要正确支持无 GIL 执行,仅仅成功编译还不够:借用引用、容器访问、内部缓存以及原生全局变量,都可能需要调整同步或所有权规则。

历史发展与替代设计

GIL 出现在 CPython 早期的多线程实现中,当时的条件与现代众核系统不同。粗粒度的解释器锁提供了一种切实可行的方式,既能加入线程支持,又能保持引用计数实现的简洁,以及扩展接口的易于管理。随着多核处理器日益普及,普通的 CPU 密集型 Python 线程无法同时利用多个核心,逐渐成为更突出的架构局限。

早期一次颇具影响力的去锁尝试,是 Greg Stein 在 20 世纪 90 年代开展的自由线程化工作。这项工作用更细粒度的保护取代了大范围的串行化,但它给常见执行路径带来的开销,使这一方案难以在主流实现中获得采用。当时的问题并不只是能否构建一个没有 GIL 的解释器,而是它能否在单线程性能、兼容性、内存占用和可维护性方面都维持可接受的水平。

Antoine Pitrou 重新设计的 GIL 于 2011 年被纳入 Python 3.2,解决的是调度和锁争用行为问题,而非消除串行化。此前的线程切换机制可能让一个 CPU 密集型线程反复重新获取锁,而另一个线程却迟迟难以获得运行机会。这次重新设计改变了锁的交接机制和计时模型,改善了响应性的一方面,但并没有把受 GIL 保护的单个解释器变成能够并行执行字节码的引擎。

不同的 Python 实现作出了不同选择。Jython 运行于 Java虚拟机之上,不使用 CPython 的 GIL。面向 .NET 环境实现的 IronPython 同样采用了不同的线程架构。这些实现表明,Python 的语言定义并不要求使用全局解释器锁,但它们的扩展兼容性和执行特性与 CPython 不同。不能想当然地认为,专为 CPython 编写的二进制扩展无需修改就能在其他运行时上工作。

另一个 Python 实现 PyPy 尽管采用了不同的执行架构和追踪式即时编译器,但通常仍保留 GIL。它也曾探索涉及事务式执行的实验性方案,不过这些方案尚未取代其常规模式。因此,采用不同的解释器或编译技术,并不意味着自然就能避免使用 GIL。

类似术语也出现在 Python 之外。Ruby 的主要实现 CRuby 使用全局虚拟机锁(Global VM Lock,简称 GVL),使大量 Ruby 代码的执行串行化,同时允许部分原生代码或阻塞操作在锁外执行。它具体保护的范围和释放锁的行为与 CPython 不同。粗粒度解释器锁只是众多设计选择中的一种,其他选择还包括细粒度锁、Actor 式隔离、不可变共享对象,以及独立执行上下文之间的消息传递。

解释器间隔离与自由线程 CPython

CPython 近年来沿着两条不同的路线来提高并行能力。一条路线将工作隔离到可以独立运行的解释器中;另一条则允许多个线程在同一个解释器内执行,而不受 GIL 约束。这两种方法解决的是不同的共享问题。独立解释器减少了共享的可变运行时状态,而自由线程执行则保留了广泛共享的对象环境,需要更有针对性地进行同步。

在 Python 3.12 中实现的 PEP 684 引入了对每解释器 GIL 的支持。通过相关的 C API 配置,可以创建各自拥有独立锁的解释器。在这类不同解释器中运行的线程可以并行执行 Python 代码。子解释器此前就已存在,但过去一直共享进程级的 GIL;因此,子解释器的存在本身在过去并不意味着 Python 代码能够并行执行。扩展模块也需要具备适当的隔离能力,才能在这种配置下安全运行。

独立解释器并不像普通线程那样共享所有 Python 对象。它们各自拥有独立的解释器状态,通信时必须遵守对象共享方面的限制。因此,从概念上看,它们可能更接近独立进程,不过它们仍处于同一个进程中,并共享一些底层资源。基于进程的并行仍是另一种选择,可以使用进程间通信或受控的共享内存,但在启动、序列化和故障隔离方面有着不同的成本。

由 Sam Gross 撰写、于 2023 年获准的 PEP 703 提出了让 CPython 的 GIL 变为可选的方案。2024 年发布的 Python 3.13 引入了实验性的自由线程构建版本。随后,Python 3.14 按照 PEP 779 所述的分阶段过渡方案,将自由线程 Python 提升为正式支持状态;但它仍是可选的构建版本,并未让所有 Python 执行都摆脱 GIL。在判断程序是否确实在无 GIL 的情况下运行时,版本、构建配置、运行时设置以及导入的扩展都需要考虑。

自由线程机制用多种相互配合的技术取代了单一的大范围保护机制。偏向引用计数使对象所属线程执行的许多引用更新操作成本更低,而共享引用处理机制则支持其他线程访问对象。延迟引用计数和永生对象减少了部分引用更新开销。容器采用内部锁和精心设计的访问路径,内存管理方面的改动也有助于保障并发访问的安全。垃圾回收仍然需要协调,并且可能暂停参与其中的线程。

这些技术只是重新分配了同步成本,而非将其消除。存在竞争的对象、内存分配器的行为、缓存一致性以及本地库的共享状态,都可能限制并行扩展能力。内部锁通常保障的是运行时的完整性,而不是应用程序中多步骤算法的原子性。因此,即使现有代码过去在 GIL 下看起来运行可靠,也可能需要显式同步。扩展兼容性、单线程开销、内存消耗以及实际场景中的多核性能,仍然是评估 CPython 不同执行配置的核心标准。