Python GIL到底是什么，为什么很多人误解它

用户11081884

发布于 2026-07-20 20:09:57

300

文章被收录于专栏：用户11081884的专栏用户11081884的专栏

一、GIL是什么？一把必要的“安全锁”

GIL，全称Global Interpreter Lock，是CPython解释器内部的一个互斥锁。规则很简单：同一个进程里，任何时候只有一个线程能执行Python字节码。

为什么需要这么粗暴的设计？这要追溯到Python的内存管理机制。Python用引用计数来管理内存——每个对象都有一个计数器，记录有多少引用指向它，计数器归零时内存立即释放。

想象这样一个场景：两个线程同时操作同一个对象，线程A刚读完引用计数准备加1，线程B却已经把计数减到0并释放了内存。这时线程A的加1操作就指向了一块废内存，程序直接崩溃。要避免这类竞态条件，最直接的办法就是把字节码执行串行化——GIL就这么来的。

GIL的初衷是守护者，不是绊脚石。它用最简单的设计保障了解释器内部的内存安全，代价是牺牲了一部分多核并行能力。

二、常见的三个误解

误解一：Python多线程完全没用，无法加速程序。

只对了一半。对于纯CPU密集型计算（用Python循环跑大量数据），GIL确实让多线程没法并行跑多核，线程得排队执行字节码，加速效果有限，甚至因为切换开销跑得更慢。

但I/O密集型任务（网络请求、读写文件、数据库查询）是另一回事。线程等待I/O时会主动释放GIL，其他线程立刻接手执行。一个线程阻塞不影响其他线程，并发效果相当好。

误解二：GIL是Python语言的设计缺陷。

GIL是CPython解释器的实现细节，不是Python语言规范的一部分。Jython（基于JVM）和IronPython（基于.NET）都没有GIL。当年设计CPython时单核CPU是主流，在简单性、安全性和性能之间选GIL是合理的工程权衡，不是什么低级失误。

误解三：有了GIL，就不用操心线程安全了。

这个最危险。GIL只保证了解释器级别的字节码执行和基础引用计数的原子性，你自己的业务逻辑它管不了。

一个典型例子：i+= 1 看着像一步操作，实际上对应“读取i的值 → 计算i+1 → 写回i”三个字节码步骤，多线程下照样数据竞争：

import threading

class UnsafeCounter:
    def__init__(self):
        self.value = 0

    def increment(self):
        # 这行代码在字节码层面不是原子的
        self.value = self.value+1

counter = UnsafeCounter()

def worker():
    for_inrange(100000):
        counter.increment()

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

for t in threads:
    t.join()

print(f"预期结果: 500000, 实际结果: {counter.value}")
# 多次运行，实际结果几乎每次都小于500000

三、根据场景选策略

I/O密集型（网络服务、文件处理）：直接用多线程

GIL在I/O等待时会释放，线程并发效果好。这是Python多线程最擅长的地方：

import threading
import time
import requests

def fetch_url(url):
    print(f"{threading.current_thread().name} 开始请求 {url}")
    # requests.get() 等待网络响应期间，GIL会被释放
    response = requests.get(url, timeout=5)
    print(f"{threading.current_thread().name} 完成，状态码: {response.status_code}")
    returnlen(response.text)

urls = ['https://httpbin.org/delay/1'] *5  # 5个各延迟1秒的接口

start = time.time()
threads = []
results = []
for i, url in enumerate(urls):
    t = threading.Thread(target=lambdau=url: results.append(fetch_url(u)), name=f"Worker-{i}")
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"总耗时: {time.time() - start:.2f}秒")
# 5个任务并发执行，总耗时略大于1秒，而非5秒

CPU密集型（科学计算、数据处理）：两条路

一是用多进程（multiprocessing）。每个进程有独立的解释器和内存空间，完全绕开GIL：

from multiprocessing import Pool, cpu_count
import time

def calculate_prime(n):
    """计算第n个素数（简易版）"""
    count = 0
    num = 2
    while count<n:
        is_prime = True
        for i in range(2, int(num**0.5)+1):
            if num%i == 0:
                is_prime = False
                break
        if is_prime:
            count += 1
        num += 1
    return num-1

if __name__ == '__main__':
    tasks = [10000, 15000, 20000, 25000]

    start = time.time()
    for task in tasks:
        calculate_prime(task)
    single_time = time.time() -start
    print(f"单进程顺序执行耗时: {single_time:.2f}秒")

    start = time.time()
    with Pool(processes=cpu_count()) as pool:
        results = pool.map(calculate_prime, tasks)
    multi_time = time.time() -start
    print(f"多进程并行执行耗时: {multi_time:.2f}秒")
    print(f"加速比: {single_time / multi_time:.2f}x")

二是用NumPy、Pandas、Polars这类计算库。它们的核心计算用C/C++/Rust写的，跑计算时会释放GIL，多核并行是真实的：

import numpy as np
import threading
import time

def matrix_power_computation():
    """NumPy矩阵运算，底层C代码会释放GIL"""
    matrix = np.random.rand(2000, 2000)
    result = np.linalg.matrix_power(matrix, 3)
    return result.shape

def run_with_threads(n_threads):
    threads = []
    start = time.time()
    for i in range(n_threads):
        t = threading.Thread(target=matrix_power_computation, name=f"NumPy-Worker-{i}")
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    elapsed = time.time() -start
    print(f"{n_threads}个NumPy线程任务总耗时: {elapsed:.2f}秒")
    return elapsed

run_with_threads(2)

高并发I/O场景还有第三条路：asyncio异步编程。单线程、无GIL干扰、切换开销最小：

import asyncio
import aiohttp
import time

async def async_fetch_url(session, url):
    print(f"开始请求: {url}")
    asyncwith session.get(url) asresponse:
        text = await response.text()
        print(f"完成: {url}, 长度: {len(text)}")
        return len(text)

async def main():
    urls = ['https://httpbin.org/delay/1'] *5
    async with aiohttp.ClientSession() as session:
        tasks = [async_fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
    print(f"所有异步任务完成。结果长度列表: {results}")

start = time.time()
asyncio.run(main())
print(f"异步I/O总耗时: {time.time() - start:.2f}秒")

追求更高性能：关注Python 3.12/3.13的新动向

Python 3.12通过PEP 684引入了“每解释器GIL”——单进程内可以创建多个拥有独立GIL的子解释器，实现真正的进程内并行（目前主要通过C-API使用）。

Python 3.13走得更远，提供了可以禁用GIL的自由线程构建版本。线程可以真正并行跑，但代价是开发者得像写C++/Java一样，手动用锁保证线程安全：

# Python 3.13+ 自由线程模式
import threading
import sys

if has attr(sys, '_is_gil_enabled') and not sys._is_gil_enabled():
    print("警告：运行在无GIL模式，必须显式保证线程安全！")

class BankAccount:
    """无GIL环境下，共享状态必须加锁"""
    def__init__(self, balance):
        self.balance = balance
        self._lock = threading.Lock()

    def transfer(self, to_account, amount):
        with self._lock:
            if self.balance>= amount:
                self.balance -= amount
                to_account.deposit(amount)
                returnTrue
        returnFalse

    def deposit(self, amount):
        with self._lock:
            self.balance += amount