🔒 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, пока выполняет байткод, и отдаёт его в трёх случаях:
- Блокирующий I/O и ожидание.
socket.recv, чтение файла,time.sleep, ожиданиеLockилиQueue.getотпускают GIL на время ожидания. Пока один поток ждёт ответ базы, другой выполняет Python - C-код, которому объекты Python не нужны. Расширение может отпустить GIL на время чистых вычислений над своими буферами. Так делают numpy на многих операциях с массивами и
hashlib: по документации он отпускает GIL, если за один вызов конструктора или.update()получил больше 2047 байт - Принудительное переключение. Если другой поток ждёт 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 вернётся | только поддерживающие несколько интерпретаторов | все |
| Цена | нет параллелизма на CPU | 5–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 — документация субинтерпретаторов с примерами и разбором, что можно передавать между ними