К содержимому
Войти

Python Road Map

🔒 GIL и free-threading

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

🧠 Как это устроено

Зачем CPython блокировка

Каждый объект в CPython хранит счётчик ссылок, и каждое присваивание, вызов функции или добавление в список его меняет. Обычный инкремент в C не атомарен: два потока одновременно прочитали 5, оба записали 6, а ссылок на самом деле 7. Дальше объект освобождается, пока на него ещё смотрят, и процесс падает. Подробнее — на странице про память и GC

Сделать атомарным каждый инкремент дорого, повесить замок на каждый объект — ещё дороже. GIL решает задачу одним замком на весь интерпретатор, и у этого решения три плюса:

  • однопоточный код быстрый, потому что внутри нет ни атомарных операций, ни мелких блокировок
  • C-расширения писать просто: автор numpy или драйвера базы может считать, что пока его функция держит GIL, никто другой объекты Python не трогает
  • внутренние структуры (словари, списки, кэши интерпретатора) защищены без отдельной работы

Плата — потоки одного процесса не выполняют Python-код параллельно на разных ядрах

Когда поток отпускает GIL

Поток держит GIL, пока выполняет байткод, и отдаёт его в трёх случаях:

  1. Блокирующий I/O и ожидание. socket.recv, чтение файла, time.sleep, ожидание Lock или Queue.get отпускают GIL на время ожидания. Пока один поток ждёт ответ базы, другой выполняет Python
  2. C-код, которому объекты Python не нужны. Расширение может отпустить GIL на время чистых вычислений над своими буферами. Так делают numpy на многих операциях с массивами и hashlib: по документации он отпускает GIL, если за один вызов конструктора или .update() получил больше 2047 байт
  3. Принудительное переключение. Если другой поток ждёт GIL, текущему через интервал переключения ставят флаг «отдай». По умолчанию sys.getswitchinterval() возвращает 0.005, то есть 5 мс. Интервал меняет sys.setswitchinterval()

С третьим пунктом есть тонкость, которая пригодится ниже. Интерпретатор проверяет флаг «отдай GIL» не после каждой инструкции, а в отдельных точках: на входе в функцию, на переходе назад в цикле, на вызовах. Между двумя такими точками поток GIL не отдаст, даже если интервал истёк

Почему I/O ускоряется, а CPU нет

Сетевой запрос — это в основном ожидание: потоки спят в recv, GIL свободен, и запросы идут параллельно. CPU-задача вроде цикла по миллиону чисел никогда не ждёт, поэтому потоки по очереди забирают GIL каждые 5 мс, а суммарная работа остаётся той же

Замер на Python 3.14.9: четыре задачи на пуле из одного и из четырёх потоков. Абсолютные цифры зависят от машины, на M1 Pro порядок такой:

Задача1 поток4 потока
Цикл s += i * i на 5 млн итераций0,76 с0,77 с
time.sleep(0.5)2,03 с0,51 с
hashlib.sha256 по буферу 200 МБ0,35 с0,09 с

Третья строка показывает, что GIL мешает только Python-коду. Хеширование идёт в C с отпущенным GIL, и четыре потока дают почти четырёхкратное ускорение. Как выбирать между потоками, процессами и asyncio, разобрано на первой странице модуля про конкурентность

Что GIL не защищает

GIL гарантирует целостность интерпретатора, а не твоих данных. Он не даёт сломать счётчик ссылок или внутренности словаря, но твоя операция из нескольких инструкций может прерваться посередине. counter += 1 в байткоде 3.14 выглядит так:

LOAD_GLOBAL              0 (counter)
LOAD_SMALL_INT           1
BINARY_OP               13 (+=)
STORE_GLOBAL             0 (counter)

Если поток прочитал counter и отдал GIL, а другой за это время увеличил значение, первый запишет устаревший результат

🛠️ На практике

Гонка на +=

В 3.14 голый counter += 1 в четырёх потоках по миллиону раз дал ровно 4 000 000 в пяти запусках из пяти. Не помог и sys.setswitchinterval(1e-6). Причина — в тонкости из раздела выше: между LOAD_GLOBAL и STORE_GLOBAL нет точки, где поток отдаёт GIL. На Python 3.9 тот же код терял увеличения в каждом запуске, около половины из 4 млн, поэтому его до сих пор показывают в статьях

Полагаться на это нельзя. Достаточно вызова функции между чтением и записью, и счётчик теряет увеличения уже с интервалом по умолчанию:

import threading

counter = 0

def step():
    return 1

def work(n):
    global counter
    for _ in range(n):
        counter += step()   # вызов между чтением и записью — точка переключения

threads = [threading.Thread(target=work, args=(1_000_000,)) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(counter)

Три запуска на 3.14.9 дали 2 410 850, 2 595 262 и 2 016 161 вместо 4 000 000. В реальном коде такой вызов есть почти всегда: self.total += item.price(), stats[key] += len(data). Вывод для собеседования: если несколько потоков меняют общее значение, нужен Lock, а безопасность без него — особенность конкретной версии, а не гарантия языка. Как правильно синхронизировать, разобрано на странице «Гонки и синхронизация»

Free-threaded сборка

Free-threaded CPython — отдельная сборка без GIL по PEP 703. Чтобы убрать GIL и не сломать счётчик ссылок, в ней счётчик стал «смещённым»: поток-владелец объекта меняет свою часть без атомарных операций, а остальные потоки — отдельную часть атомарно. Объекты вроде None, малых чисел и констант кода стали бессмертными, их счётчик вообще не меняется

История по версиям:

ВерсияСтатус
3.13экспериментальная сборка, отдельный бинарник python3.13t, заметное замедление однопоточного кода
3.14официально поддерживается, но не по умолчанию (PEP 779, фаза II). Бинарник python3.14t
3.15стабильный ABI для free-threaded сборок abi3t (PEP 803), официальный установщик для macOS по умолчанию ставит и free-threaded сборку

Как проверить, где ты находишься:

import sys, sysconfig

print(sysconfig.get_config_var("Py_GIL_DISABLED") == 1)  # сборка умеет работать без GIL
print(sys._is_gil_enabled())                              # GIL включён прямо сейчас

В обычной сборке первая строка напечатает False, вторая True. В free-threaded сборке GIL можно вернуть переменной окружения PYTHON_GIL=1 или флагом -X gil=1, а PYTHON_GIL=0 и -X gil=0 держат его выключенным

Чем платят. По What's New 3.14 однопоточный код в free-threaded сборке медленнее примерно на 5–10% в зависимости от платформы и компилятора. HOWTO по free-threading приводит средние по pyperformance: около 1% на macOS aarch64 и до 8% на x86-64 Linux. PEP 779 ставил для фазы II потолок 15% по скорости и 20% по памяти

Главная ловушка — C-расширения. Расширение нужно собрать отдельно под free-threaded сборку и явно пометить, что оно работает без GIL. Если импортировать расширение без такой пометки, интерпретатор включит GIL обратно для всего процесса и только напечатает предупреждение. До 3.15 каждый пакет собирался под каждую версию отдельно (колёса cp314t), с 3.15 автор может собрать одно колесо abi3t для обычных и free-threaded сборок, если переведёт расширение на новый API

Чистый Python-код потокобезопасен примерно в той же мере, что и с GIL. Гонка на += остаётся, а одновременное чтение одного итератора из нескольких потоков может пропускать или дублировать элементы

Когда пробовать free-threaded сборку:

  • есть CPU-задача на чистом Python, которую неудобно выносить в процессы из-за больших общих данных в памяти
  • все зависимости с C-кодом отмечены как совместимые в трекере py-free-threading (ссылка внизу)
  • ты готов прогнать нагрузочные тесты и поймать гонки, которые раньше прятал GIL

Типичный веб-сервис на Django или FastAPI упирается в базу и сеть, а не в GIL, и выигрыша почти не заметит

Субинтерпретаторы

С 3.12 у каждого субинтерпретатора свой GIL, а с 3.14 ими можно управлять из Python: модуль concurrent.interpreters (PEP 734) и concurrent.futures.InterpreterPoolExecutor. Субинтерпретатор — отдельный интерпретатор в том же процессе со своими модулями и builtins. Объекты между ними не общие, по умолчанию передача идёт через pickle, а None, числа, строки, bytes и кортежи из них передаются дешевле. Реально общие данные дают только memoryview и очередь interpreters.create_queue()

Тот же CPU-цикл из замера, четыре задачи на пуле из четырёх воркеров, Python 3.14.9:

from concurrent.futures import InterpreterPoolExecutor

def cpu(n):
    s = 0
    for i in range(n):
        s += i * i
    return s

if __name__ == "__main__":
    with InterpreterPoolExecutor(4) as ex:
        print(len(list(ex.map(cpu, [5_000_000] * 4))))

На той же машине ThreadPoolExecutor справился за 0,75 с, InterpreterPoolExecutor за 0,25 с, ProcessPoolExecutor за 0,31 с. Субинтерпретаторы дали параллелизм процессов без запуска новых процессов. Ограничения из What's New 3.14: старт интерпретатора пока не оптимизирован, памяти каждый берёт больше, чем мог бы, а многие пакеты с C-кодом в субинтерпретаторах ещё не работают. Изоляция внутри процесса не граница безопасности: код с доступом к памяти процесса видит всё

Четыре способа получить параллелизм

Обычные потокиFree-threaded потокиСубинтерпретаторыПроцессы
Python-код на нескольких ядрахнетдадада
Общие объектывсевсепочти нет, копия через pickleнет, копия через pickle
Нужен Lock для общих данныхдадатолько для общих буферовнет, но нужна синхронизация через IPC
C-расширениявсетолько помеченные, иначе GIL вернётсятолько поддерживающие несколько интерпретатороввсе
Ценанет параллелизма на CPU5–10% на однопоточном кодедорогой старт, память на каждый интерпретаторпроцесс на воркер, сериализация

⚠️ Где ошибаются

«GIL есть, значит Lock не нужен». GIL защищает интерпретатор, а не составные операции. Проверка в 3.14 «у меня += 1 не гоняется» ничего не доказывает: добавь вызов функции, смени версию или запусти на free-threaded сборке, и счётчик поедет

Ускорять CPU-код потоками в обычной сборке. Пул из 8 потоков на подсчёте статистики загружает одно ядро и добавляет переключения. Для CPU — процессы, субинтерпретаторы или C-код с отпущенным GIL

Считать, что python3.14t без GIL всегда. Одно старое расширение в зависимостях, и GIL включился для всего процесса. Проверяй sys._is_gil_enabled() после импортов и смотри предупреждения при запуске

Путать субинтерпретаторы с потоками. Функция в InterpreterPoolExecutor не видит глобальные переменные основного интерпретатора, а аргументы и результат копируются. Лямбду или открытое соединение с базой туда не передать

🎯 Вопросы с собеседований

Что такое GIL и зачем он нужен

Глобальная блокировка CPython: байткод в процессе одновременно выполняет только один поток. Она нужна, потому что счётчики ссылок и внутренние структуры интерпретатора не потокобезопасны, а атомарные операции или замок на каждый объект замедлили бы однопоточный код. Заодно GIL упрощает C-расширения: пока функция держит GIL, другие потоки объекты не трогают. Плата — потоки не дают параллелизма на чистом Python-коде. Это свойство CPython, а не языка

Что GIL защищает, а что нет? Нужен ли Lock, если есть GIL?

GIL защищает целостность интерпретатора: счётчик ссылок, внутренности списков и словарей, поэтому один list.append из разных потоков не портит список. Но операция из нескольких инструкций, как counter += 1, это чтение, сложение и запись, и поток может отдать GIL между ними. Тогда два потока прочитают одно значение, и одно увеличение потеряется. В 3.14 голый += 1 на глобальной переменной почти не гоняется, потому что между чтением и записью нет точки переключения, но с вызовом функции внутри увеличения теряются сразу. Значит, общее изменяемое состояние защищают Lock, а не надеются на GIL

Почему потоки ускоряют I/O, но не CPU-задачи в обычном CPython?

Поток отпускает GIL на время блокирующего ожидания: сокет, файл, time.sleep. Поэтому десять HTTP-запросов в десяти потоках занимают время самого медленного, а не сумму. CPU-код никогда не ждёт, потоки по очереди забирают GIL каждые 5 мс, и суммарная работа не сокращается. Исключение — C-код, который сам отпускает GIL, например hashlib на больших буферах или многие операции numpy: такие потоки масштабируются

Free-threaded Python: что это, чем платят, готовы ли библиотеки?

Отдельная сборка CPython без GIL по PEP 703: в 3.13 экспериментальная, в 3.14 официально поддерживается, но не по умолчанию (PEP 779). Потоки выполняют Python-код на разных ядрах. Платят скоростью однопоточного кода, по What's New 3.14 это примерно 5–10%, и дополнительной памятью. С библиотеками главный риск — C-расширения: их надо собрать под free-threaded сборку и пометить, иначе при импорте GIL включится обратно с предупреждением. Готовность пакетов смотрят в трекере py-free-threading, а в 3.15 появился abi3t, одно колесо для обеих сборок

Чем субинтерпретаторы отличаются от процессов и потоков?

У субинтерпретатора свой GIL, свои модули и свои объекты, но он живёт в том же процессе. От потоков отличается тем, что объекты не общие: аргументы копируются через pickle, общими бывают только memoryview и специальные очереди. Зато CPU-код идёт параллельно. От процессов отличается тем, что не нужен новый процесс и межпроцессное общение, но изоляция слабее: это не граница безопасности, а часть C-расширений в субинтерпретаторах ещё не работает. В 3.14 их дают concurrent.interpreters и InterpreterPoolExecutor

📚 Что почитать

  • Python support for free threading — официальный HOWTO: как определить сборку, включить GIL обратно и какие у неё ограничения
  • PEP 703 — зачем был GIL и как без него устроен счётчик ссылок
  • Python Free-Threading Guide — трекер совместимости пакетов с C-кодом и гайды по переносу расширений
  • concurrent.interpreters — документация субинтерпретаторов с примерами и разбором, что можно передавать между ними