GIL 是 Python 语言中的一个锁机制，用于保证同一时刻只有一个线程在运行。GIL 的作用是保证 Python 语言的多线程安全，避免多个线程同时操作同一个变量时产生数据不一致的问题。在高并发、性能优化、系统架构设计的场景下，GIL 的存在可能会导致性能下降，因此，如何绕过 GIL 是一个重要的问题。

GIL 是什么？

GIL = Global Interpreter Lock（全局解释器锁）

它是 CPython 解释器（最主流的 Python 实现）中的一个互斥锁（mutex），用来保证同一时刻只有一个线程在执行 Python 字节码。

注意：

• GIL 是 CPython 的特性，不是 Python 语言本身的特性。
• 其他实现如 Jython、IronPython、PyPy（部分版本）没有 GIL。
• 所以讨论 GIL 时，默认是指 CPython。

GIL 为什么存在？

CPython 的内存管理（如对象引用计数）不是线程安全的。例如：

1
2

a = []
a.append(1)  # 这行代码在底层其实是多个字节码指令

在多线程环境下，如果没有 GIL，两个线程同时操作同一个对象，可能导致引用计数错误、内存泄漏或崩溃。

GIL 的设计初衷：简化 CPython 的内存管理实现，提高单线程性能，保证线程安全。

GIL 对多线程/多进程的影响

1. 对多线程（threading）的影响

CPU 密集型任务 → 性能严重受限

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import threading
import time

def cpu_bound_task():
    total = 0
    for i in range(10**7):
        total += i

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

for t in threads:
    t.join()

print("Time taken:", time.time() - start)

在 4 核 CPU 上，你会发现执行时间几乎和单线程一样！因为 GIL 导致多个线程无法并行执行 Python 字节码。

I/O 密集型任务 → 影响较小，甚至有提升

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import threading
import time
import requests

def io_bound_task():
    requests.get("https://httpbin.org/delay/1")  # 模拟网络请求

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

for t in threads:
    t.join()

print("Time taken:", time.time() - start)  # 大约 1.x 秒，而不是 4 秒

为什么？因为 I/O 操作（如网络、文件读写）会主动释放 GIL，让其他线程运行。所以多线程在 I/O 场景下能并发执行。

总结：

对多进程（multiprocessing）的影响

多进程完全绕过 GIL！

因为每个进程拥有独立的 Python 解释器和内存空间，自然有独立的 GIL。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import multiprocessing
import time

def cpu_bound_task():
    total = 0
    for i in range(10**7):
        total += i

start = time.time()
processes = []
for _ in range(4):
    p = multiprocessing.Process(target=cpu_bound_task)
    processes.append(p)
    p.start()

for p in processes:
    p.join()

print("Time taken:", time.time() - start)  # 时间约为单进程的 1/4（理想情况）

适用场景：CPU 密集型任务

代价：

• 进程创建/销毁开销大
• 进程间通信（IPC）成本高（需用 Queue、Pipe、共享内存等）
• 内存占用高（每个进程独立内存）

如何“绕过” GIL？

虽然不能“删除” GIL（除非换解释器），但我们可以通过以下方式规避其限制：

方案 1：使用 multiprocessing（推荐用于 CPU 密集型）

• 适合：图像处理、科学计算、数据清洗、机器学习预处理等
• 示例：用 multiprocessing.Pool 并行处理数据

1
2
3
4
5
6
7

from multiprocessing import Pool

def square(x):
    return x * x

with Pool(4) as p:
    result = p.map(square, range(1000000))

优势：真正并行，充分利用多核
劣势：进程开销、不适合频繁小任务

方案 2：使用 asyncio + 异步 I/O（推荐用于 I/O 密集型）

• 适合：网络请求、数据库访问、文件读写等
• 利用事件循环 + 协程，在 I/O 等待时切换任务，单线程内并发

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import asyncio
import aiohttp

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, "https://httpbin.org/delay/1") for _ in range(10)]
        await asyncio.gather(*tasks)

asyncio.run(main())

优势：高并发、低开销、适合海量 I/O
劣势：不能加速 CPU 计算；需异步生态支持（库要 async 兼容）

注意：asyncio 本身不绕过 GIL，但它避免了“阻塞等待”，让单线程更高效。

方案 3：使用外部服务或进程外计算

• 把计算密集型任务交给 Go / Rust / Java 服务，通过 HTTP/gRPC 调用
• 或使用任务队列（Celery + 多进程 Worker）异步处理

常见疑问

为什么 Python 有 GIL？它是不是 Python 的缺陷？

• GIL 是 CPython 的实现选择，不是语言缺陷
• 目的是简化内存管理、保证线程安全、提升单线程性能
• 对 I/O 密集型应用影响小，对 CPU 密集型是瓶颈
• 社区曾尝试移除 GIL（如 Gilectomy），但因性能倒退、兼容性问题失败
• 现实中我们用 multiprocessing/asyncio/C 扩展 绕过它

多线程和多进程如何选择？

• I/O 密集 → 多线程 or asyncio（轻量、切换快）
• CPU 密集 → 多进程 or C 扩展（真正并行）
• 小任务、高频 → 避免多进程（开销大），考虑线程池/协程
• 数据共享复杂 → 多线程更方便（共享内存）；多进程需 IPC

asyncio 能解决 GIL 问题吗？

• 不能“解决”，但能“规避影响”
• asyncio 通过事件循环 + 协程，在 I/O 等待时切换任务，提高单线程利用率
• 对 CPU 密集任务无效，甚至因单线程更慢
• 本质是“并发”，不是“并行”

性能对比示意（简化版）

最佳实践：I/O 用 asyncio，CPU 用 multiprocessing，混合型用“多进程 + 每个进程内 asyncio”

总结