Python 里的 GIL 是什么(曾是?)?

……用代码讲清楚。

|  |  |  |   |

开源项目（OPEN-SOURCE）

RAG 很强大，但它有一个致命问题：每一次查询都要打到向量数据库（vector DB），哪怕那些几个月都没变过的静态信息也不例外。这既昂贵又缓慢，而且完全没必要。缓存增强生成（Cache-Augmented Generation，CAG） 解决了这个问题——它让模型把静态信息直接保留在自己的键值（Key-Value，KV）记忆里，而这正是模型在读取每个 token 时为内部构建的东西。你还可以更进一步，把 RAG 和 CAG 融合起来，如下图所示： 下面用通俗的方式讲讲它的原理：

• 在常规的 RAG 架构中，你的查询会先进入向量数据库，检索出相关文本块（chunk），再喂给 LLM。
• 但在 RAG + CAG 中，你会把知识分成两个层次。

  • 静态、很少变动的数据（比如公司制度、参考手册）会被一次性缓存进模型的 KV 记忆里。
  • 动态、频繁更新的数据（比如最近的客户交互、实时文档）则继续通过检索（retrieval）获取。

这样一来，推理更快、成本更低，重复劳动也更少。诀窍在于：只缓存该缓存的东西。只把那些静态、高价值、很少变化的知识缓存起来。如果你什么都缓存，很快就会撞上上下文（context）上限。把「冷」（可缓存）和「热」（可检索）数据分开，整套系统才可靠。要落地这一点，你其实现在就能上手——因为 OpenAI 和 Anthropic 的 API 都已经支持 提示词缓存（prompt caching） 了。在规模化之前，有一点必须先知道：提示词缓存是按精确前缀逐字节匹配的。所以一个缓存层只有在每次都处在上下文最前端、且顺序完全一致时才会被复用。也就是说，如果你：↳ 调换两份缓存好的政策文档的顺序，两份都会变成未命中（miss）↳ 单独缓存文档 A、单独缓存文档 B，然后同时查询两者，第二个会未命中，因为模型计算自己的缓存状态时从未见过第一个。在生产环境中，这表现为：一小部分缓存块贡献了几乎所有的命中，其余的只是一动不动地待着。破局的思路来自注意力的行为方式：token 主要只关注自己所在的局部邻域，只有极少数会跨越文档边界。 CacheBlend 是一种技术，它只重新计算那少数几个 token，其余部分全部复用各自独立缓存的文档。多文档查询的运行速度能提升到原来的 2–4 倍，质量不变，顺序也不再重要。这个方法在 LMCache 中实现，完全开源。GitHub 仓库：https://github.com/LMCache/LMCache^[2]​（别忘了点个 star 🌟） |  

Python

多年来，GIL（全局解释器锁，Global Interpreter Lock） 一直是多线程 Python 代码最大的性能瓶颈。而在 Python 3.14 中，你第一次可以不带 GIL 运行 Python 了。关于 Python 中的 GIL，下面是你所有需要了解的内容。今天，就让我们深入了解一下吧！

一些基础概念

• 进程（process） 与其他进程相互隔离，运行在各自独立的内存空间里。这种隔离意味着，如果某个进程崩溃，通常不会影响到其他进程。

• 多线程（multi-threading） 是指一个进程内拥有多个线程。这些线程共享同样的资源，比如内存。

什么是 GIL？

简单来说，GIL（全局解释器锁） 限制一个进程同一时刻只能运行一个线程。 换句话说，一个进程可以有多个线程，但任意时刻只有一个能真正运行。这意味着进程无法利用多个 CPU 核心来做性能优化，也就是说，多线程带来的性能与单线程几乎无异。 让我们用一个代码演示来理解吧！

• 首先，我们做几个导入，并定义一个耗时的函数：

• 单线程 情况下，我们连续调用同一个函数两次，耗时 0.432 秒。

• 多线程 情况下，我们创建两个线程，每个函数各一个，耗时 0.428 秒：

 尽管用了多线程，运行时间却差不多，原因正是……GIL。顺带一提，使用多进程（multi-processing） 时我们确实看到了运行时间的提升： 上面三种场景（单线程、多线程、多进程）可以用下图直观地解释：

• 单线程（Single-threading）：一个线程按顺序把同一个函数执行两遍：

• 多线程（Multi-threading）：每个线程被分配到执行一次函数的工作。但受 GIL 限制，同一时刻只有一个线程能运行：

• 多进程（Multi-processing）：每个函数在不同的进程下执行：

 如果这已经清楚了，那我们现在来回答两个问题：

1) 既然 GIL 并非最优，Python 为什么一直还在用它？

线程安全（thread safety）。当多个线程在一个进程里运行、并共享同样的资源（比如内存）时，如果它们试图访问并修改同一份数据，就会出问题。举个例：假设我们想用两个线程对同一个 Python 列表执行两个操作：

• 如果 t1 先于 t2 运行，会得到如下输出：

• 如果 t2 先于 t1 运行，会得到如下输出：

 我们得到了不同的输出！这会导致竞态条件（race condition）——结果取决于线程执行的时序。正是这个，再加上另外几个原因，让「一次只执行一个线程」成了省事的方案。顺便说一句，GIL 通常影响的是 CPU 密集型（CPU-bound） 任务，而不影响 I/O 密集型（I/O-bound） 任务——后者用多线程依然有用。

2) 既然多进程能行，为什么不直接用它来绕过 GIL？

说起来容易做起来难。线程共享同一块内存空间，而进程是相互隔离的。 因此，进程无法像线程那样直接共享数据。尽管存在进程间通信（IPC，Inter-Process Communication） 机制——比如管道（pipe）、队列（queue）、共享内存（shared memory）——可以在进程间交换信息，但它们会引入大量额外的复杂度。

值得高兴的是，Python 3.14 允许我们关闭 GIL，这意味着一个进程可以充分利用所有 CPU 核心。这段视频展示了运行时间的差异： ^[4] ​ 我们最近一直在测试 Python 3.14，很快就会在一期详细的通讯里分享这些进展。话说回来，如果你想真正动手实践 GPU 编程、了解 CUDA 是如何调度 GPU 的线程、线程块（block）、网格（grid）（含可视化）等内容的，我们在下面这篇文章里讲过：从零开始用 CUDA 编程实现（大规模）并行化程序^[5] 👉 交给你了：你还知道哪些 Python 坚持使用 GIL 的理由？ |  

机器学习（machine learning）

对比学习（Contrastive Learning） 是一种流行的自监督学习（self-supervised learning） 技术，它通过比较样本来教会模型学习有用的表征（representation）。我们结合一个真实任务来深入理解。假设你是一名 ML 工程师，负责搭建一个人脸解锁系统。我们来看看几种可能的方案：

1) 训练一个二分类器

当真正的用户正在开手机时，输出 1；否则输出 0。 一开始，你可以让用户录入人脸数据来训练模型。但问题恰恰出在这里：用户录入的数据全都属于「Class 1（类别 1）」。 接下来，你总不能让用户去找别人来贡献「Class 0（类别 0）」的样本吧，这对他们来说太麻烦了。而且你需要多样化的「Class 0」样本，只用一两个人的脸显然不够。于是你想到的下一个办法是……或许可以把一些负样本（Class 0） 预置到设备里来训练模型。 这或许可行。但你马上又意识到另一个问题：如果另一个人想用同一台设备呢？在模型适配（adaptation）过程中，所有新样本都会属于「新面孔」，那模型会不会把第一张脸给忘了？

2) 那迁移学习（transfer learning）呢？

• 在某个相关任务上训练一个神经网络模型（基座模型，base model）→ 这一步会在把模型下发到用户设备之前完成。
• 接着，把基座模型的最后几层替换成未训练的层，再下发到设备。

前几层已经学会了识别关键的人脸特征，之后在用户脸上训练就不需要太多数据了。但你又一次发现，这会遇到和二分类模型一样的问题——因为新加的层最终还是被设计成预测 1 或 0。

解决方案：用孪生网络（Siamese Networks）做对比学习

孪生网络（Siamese network） 的核心，是判断两个输入是否相似。 它的做法是：学习把两个输入有效地映射到同一个共享嵌入空间（embedding space）（即上图中的蓝色层）：

• 如果两个嵌入（embedding）之间的距离小，说明它们相似。
• 如果两个嵌入之间的距离大，说明它们不相似。

当任务目标是比较两个数据点、而非把它们归类到预定义类别时，这种方法特别有用。在我们的场景里，它的工作方式如下：构建一个人脸配对（face pairs）数据集：

• 如果一对属于同一个人，真实标签就是 0。
• 如果一对属于不同的人，真实标签就是 1。

构建好数据后，定义如下这样一个网络： 让两个输入都通过同一个网络，生成两个嵌入。

• 如果真实标签是 0（同一个人）→ 最小化两个嵌入之间的距离。
• 如果真实标签是 1（不同的人）→ 最大化两个嵌入之间的距离。

对比损失（Contrastive loss）（定义如下）能帮我们训练这样的模型： 其中：

• y 是真实标签。
• D 是两个嵌入之间的距离。
• margin 是一个超参数（hyperparameter），通常大于 1。

下面看看这个损失函数是如何起作用的：

• 当 y=1（不同的人）时，损失如下，当 D 接近 margin 值时取最小，从而让两个嵌入之间的距离更大。

• 当 y=0（同一个人）时，损失如下，当 D 接近 0 时取最小，从而让两个嵌入之间的距离较小。

 这样一来，我们就能保证：

• 输入相似时，它们在嵌入空间中离得更近。
• 输入不相似时，它们在嵌入空间中离得更远。

孪生网络在人脸解锁中的应用

下面看看它在人脸解锁应用里是怎么帮忙的。首先，用对比损失在若干图像配对上训练模型。 这个模型（很可能经过模型压缩（model compression）^[7] 之后）会被下发到用户设备。在设置阶段，用户提供人脸数据，由此生成一个用户嵌入（user embedding）： 这个嵌入会存储在设备内存里。之后，当用户想要解锁手机时，可以生成一个新的嵌入，并与已存储的嵌入进行比对：

• 动作：如果距离较小，就解锁手机。

搞定！注意这里不需要再做额外训练，这一点和前面的二分类方案不同。另外，如果多个人都想录入自己的脸 ID 呢？没问题。 为新用户再生成一个嵌入即可。解锁时，把新来的用户与所有已存储的嵌入逐一比对。下面还有一些动手阅读的延伸内容，教你如何构建端侧 ML 应用：

• 学习如何构建隐私优先的 ML 系统（含实现）：联邦学习：迈向隐私保护机器学习的关键一步^[8]**。
• 学习如何压缩 ML 模型、降低成本：模型压缩：迈向高效机器学习的关键一步^[9]**。

👉 交给你了：孪生网络并不是解决这个问题的唯一方式。还有哪些架构也能胜任？ |  

引用链接