Главная › Блог › Python › GIL в Python: что он даёт, что отнимает и как отвечать на собеседовании

GIL в Python: что он даёт, что отнимает и как отвечать на собеседовании

Что такое GIL

GIL (Global Interpreter Lock) — это глобальный мьютекс интерпретатора CPython, который гарантирует, что байт-код Python в один момент времени выполняет только один поток с присоединённым состоянием потока. Даже если у вас восемь ядер и восемь потоков, выполнять инструкции интерпретатора параллельно они не могут — только по очереди.

Важно сразу разделить две вещи: GIL — это особенность конкретной реализации CPython, а не языка Python как такового. Другие реализации устроены иначе, а в самом CPython начиная с версии 3.13 появилась экспериментальная сборка без GIL (см. ниже).

Зачем он вообще нужен

Главная причина — модель памяти CPython построена на подсчёте ссылок (reference counting). У каждого объекта есть счётчик ссылок, который инкрементируется и декрементируется при создании и удалении ссылок. Если бы несколько потоков одновременно меняли этот счётчик без синхронизации, возникали бы гонки: счётчик мог бы стать некорректным, объект удалился бы раньше времени или, наоборот, утёк бы из памяти.

Вместо того чтобы ставить блокировку на каждый объект, разработчики CPython выбрали один глобальный лок на весь интерпретатор. Это упростило реализацию и избавило однопоточный код от накладных расходов на синхронизацию там, где потоков нет вообще.

GIL — это как единственный микрофон в переговорной. Говорить может только тот, у кого микрофон. Это не мешает людям присутствовать и думать параллельно (это I/O и подготовка), но произносить слова (выполнять байт-код) одновременно они не могут.

Как GIL переключается между потоками

В CPython интерпретатор периодически отпускает GIL, чтобы дать шанс другим потокам. Интервал переключения настраивается через sys.setswitchinterval(). Это деталь реализации конкретной версии CPython, а не гарантия языка. Также GIL освобождается явно при блокирующих операциях ввода-вывода — чтении файла, сетевом запросе, time.sleep().

Именно поэтому потоки в CPython хорошо подходят для I/O-bound задач: пока один поток ждёт ответа от сети или диска, GIL свободен и может исполнять байт-код другого потока. Документация threading называет это подходящей моделью использования модуля.

import threading
import time

def io_bound():
    time.sleep(1)  # GIL освобождается на время ожидания

threads = [threading.Thread(target=io_bound) for _ in range(10)]
start = time.monotonic()
for t in threads:
    t.start()
for t in threads:
    t.join()
print(time.monotonic() - start)  # ~1 секунда, а не 10

А вот с CPU-bound кодом картина другая: в стандартной (GIL-сборке) потоки выполняют байт-код по очереди, поэтому параллельного ускорения вычислений не происходит.

Документация threading прямо отмечает: GIL ограничивает выигрыш от многопоточности именно для CPU-bound задач, поскольку только один поток может исполнять байт-код одновременно. Для таких задач документация рекомендует multiprocessing или concurrent.futures.ProcessPoolExecutor.

Как обходят GIL

Есть несколько рабочих стратегий:

  • multiprocessing — запускает отдельные процессы, каждый со своим интерпретатором и своим GIL. Это обходит ограничение GIL за счёт отдельных процессов, но ценой передачи данных через сериализацию (pickle) и дополнительной памяти на каждый процесс.
  • C-расширения, отпускающие GIL — некоторые библиотеки снимают GIL на время тяжёлых операций в C-коде, позволяя нескольким потокам работать параллельно во время выполнения этого кода (упоминается в документации threading как возможность отдельных производительных библиотек).
  • asyncio — не про параллелизм, а про конкурентность в одном потоке: event loop переключается между корутинами в точках ожидания (await), и поскольку исполняется только один поток, конкуренции за GIL между корутинами нет.
Если threading — это один микрофон на всех, то multiprocessing — это несколько отдельных переговорных комнат с собственным микрофоном в каждой. Обмен данными между комнатами дороже, чем просто передать микрофон соседу.

Будущее: PEP 703 и альтернативы

Начиная с Python 3.13 существует экспериментальная сборка CPython без GIL — так называемая free-threaded build, описанная в PEP 703. Она собирается с флагом --disable-gil и помечается в ABI буквой «t». В такой сборке несколько потоков действительно могут выполнять байт-код параллельно.

В Python 3.13 это экспериментальная возможность с заметной просадкой производительности на однопоточном коде. В Python 3.14 реализация PEP 703 доработана, в интерпретаторе заработал специализирующий адаптивный режим, и штраф на однопоточных сценариях снижен примерно до 5–10% в зависимости от платформы и компилятора; сама поддержка free-threaded режима получила официальный статус (PEP 779). Для сборки C-расширений под free-threaded режим требуется pip 24.1 или новее и явная поддержка со стороны расширения (слот Py_mod_gil).

Обычная (GIL-сборка) CPython остаётся сборкой по умолчанию, и обе ветки — с GIL и без него — продолжают сосуществовать.

Почему в Python нельзя просто убрать GIL?
Потому что модель управления памятью в CPython опирается на подсчёт ссылок, корректный без гонок только при наличии какой-то синхронизации. Замена одного глобального лока на блокировки для отдельных объектов и другие механизмы — задача с существенными изменениями во внутренностях интерпретатора, и именно поэтому она реализуется поэтапно в рамках PEP 703, начиная с экспериментальной сборки в Python 3.13.
Чем GIL отличается от обычного мьютекса в коде?
GIL управляется самим интерпретатором автоматически на уровне байт-кода и I/O-операций, разработчик не берёт и не отпускает его явно. Обычный мьютекс — это инструмент, который явно ставит и снимает сам программист для защиты своих критических секций.
Ускорит ли threading парсинг большого CSV-файла в памяти?
В стандартной сборке CPython — нет, если парсинг представляет собой чистые вычисления на Python: потоки будут исполнять байт-код по очереди из-за GIL. Ускорение даст только ожидание I/O (чтение с диска), а сами CPU-bound вычисления документация рекомендует распараллеливать через multiprocessing или concurrent.futures.ProcessPoolExecutor.
Можно ли сказать, что GIL делает Python-потоки бесполезными?
Нет. Документация threading указывает, что модуль остаётся подходящим инструментом для одновременного выполнения нескольких I/O-bound задач — сетевых запросов, файловых операций. Ограничение GIL касается именно CPU-bound вычислений в стандартной сборке CPython.

Ещё разборы