🧵 Потоки, процессы и корутины
В Python три способа делать несколько дел сразу: потоки, процессы и корутины asyncio. Они по-разному платят за параллельность, и неправильный выбор легко делает программу медленнее, чем без него: пул процессов на мелких задачах в замере ниже работал почти в 900 раз дольше обычного цикла. Эта страница — карта модуля: чем механизмы отличаются и как выбрать под задачу. Детали asyncio — на следующих страницах
🧠 Как это устроено
Процесс, поток, корутина
Процесс — запущенная программа со своей памятью, своим интерпретатором и своим GIL. Два процесса не видят объекты друг друга, данные между ними передаются копией: через pickle, трубу или общую память. Зато Python-код в них идёт на разных ядрах по-настоящему
Поток живёт внутри процесса и делит с соседями всю память. Переключает потоки операционная система, в любой момент и без спроса. В обычном CPython байткод одновременно выполняет только один поток, поэтому потоки ускоряют ожидание, но не вычисления. Почему так, подробно разобрано на странице про GIL
Корутина — функция, которую можно приостановить на await и продолжить позже. Все корутины крутятся в одном потоке, а между ними переключается event loop. Переключение кооперативное: корутина отдаёт управление только сама, на await. Отсюда главное свойство asyncio: пока корутина не дошла до await, никто другой не выполняется. Отсюда же главная ловушка: один time.sleep(5) в корутине останавливает весь сервис на 5 секунд
CPU-bound и I/O-bound
Задача CPU-bound, если время уходит на вычисления: парсинг большого JSON, ресайз картинок, подсчёт статистики в цикле. Ускорить её можно только дав ей больше ядер
Задача I/O-bound, если время уходит на ожидание: ответ базы, HTTP-запрос, чтение с диска. Процессор в это время простаивает, и ускорение даёт не больше ядер, а умение ждать много ответов одновременно
Типичный бэкенд почти целиком I/O-bound: обработчик больше ждёт базу, чем считает. Поэтому веб-серверы строят на потоках или asyncio, а процессы берут для тяжёлых вычислений
Таблица выбора
| Механизм | Когда брать | Чем платишь |
|---|---|---|
threading, ThreadPoolExecutor | I/O с синхронными библиотеками: requests, драйвер базы без async, запись файлов. C-код, который отпускает GIL (hashlib, numpy) | нет параллелизма на Python-коде, гонки на общих данных, свой стек и планирование ОС на каждый поток |
multiprocessing, ProcessPoolExecutor | CPU-задача на чистом Python, которую можно разрезать на куски | десятки миллисекунд на старт процесса, pickle аргументов и результатов, память на каждый процесс |
InterpreterPoolExecutor (с 3.14) | CPU-задача, когда процессы дороги, а зависимости работают в субинтерпретаторах | молодой API, многие C-расширения ещё не поддерживают, тот же pickle для аргументов |
asyncio | много одновременных сетевых операций: тысячи соединений, вебсокеты, параллельные запросы к API | весь стек должен быть асинхронным, любой блокирующий вызов останавливает цикл |
Ещё один вариант — free-threaded сборка 3.14, где потоки идут на разных ядрах. Её цена разобрана на странице про GIL
concurrent.futures
concurrent.futures — общий интерфейс над пулами. ThreadPoolExecutor, ProcessPoolExecutor и InterpreterPoolExecutor устроены одинаково: submit(fn, x) кладёт задачу в очередь и сразу возвращает Future — обещание результата. future.result() ждёт и возвращает значение, а если функция упала, бросает то же исключение в вызывающем потоке. map запускает функцию на каждом элементе и отдаёт результаты в исходном порядке, as_completed — по мере готовности
Голые threading.Thread и multiprocessing.Process результат не возвращают: его надо складывать в очередь или общий словарь. Исключение в голом потоке напечатается в stderr и пропадёт, а основной код о нём не узнает. Executor решает обе проблемы и закрывается через with
Размер пула по умолчанию с 3.13: у потоков min(32, os.process_cpu_count() + 4), у процессов os.process_cpu_count()
🛠️ На практике
Замер: потоки против процессов
Одна и та же задача в пуле из 4 потоков и в пуле из 4 процессов. CPU — цикл s += i * i на 5 млн итераций, 4 раза. I/O — time.sleep(0.5), 8 раз. Мелкие задачи — x * x на 100 тысячах чисел
Python · Код замера
import time
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
def cpu(n):
s = 0
for i in range(n):
s += i * i
return s
def io(_):
time.sleep(0.5) # имитация ожидания сети
return 1
def tiny(x):
return x * x
def run(label, ex_cls, fn, args, **kw):
t = time.perf_counter()
with ex_cls(4) as ex:
list(ex.map(fn, args, **kw))
print(f"{label:40s} {time.perf_counter() - t:.2f} с")
if __name__ == "__main__":
run("CPU, ThreadPool(4)", ThreadPoolExecutor, cpu, [5_000_000] * 4)
run("CPU, ProcessPool(4)", ProcessPoolExecutor, cpu, [5_000_000] * 4)
run("I/O, ThreadPool(4)", ThreadPoolExecutor, io, range(8))
run("I/O, ProcessPool(4)", ProcessPoolExecutor, io, range(8))
run("мелкие, chunksize=1", ProcessPoolExecutor, tiny, range(100_000))
run("мелкие, chunksize=5000", ProcessPoolExecutor, tiny, range(100_000), chunksize=5000)Python 3.13.5, macOS, M1 Pro на 8 ядер, три запуска с разбросом в несколько процентов. На другой машине абсолютные цифры будут другими, соотношения — примерно такими же
| Задача | Без пула | 4 потока | 4 процесса |
|---|---|---|---|
| CPU, 4 × 5 млн итераций | 0,91 с | 0,88 с | 0,32 с |
I/O, 8 × sleep(0.5) | 4 с (8 × 0,5) | 1,02 с | 1,13 с |
100 тысяч вызовов x * x | 0,01 с | — | 8,7 с с chunksize=1, 0,09 с с chunksize=5000 |
Выводы:
- на CPU потоки не дали ничего, процессы ускорили почти в три раза. Не в четыре, потому что часть времени ушла на запуск процессов
- на I/O потоки и процессы равны: оба просто ждут. Процессы чуть медленнее из-за старта и держат 4 интерпретатора в памяти
- на мелких задачах пул процессов почти в 900 раз медленнее обычного цикла. Каждый вызов
x * x— этоpickleаргумента, передача по трубе в другой процесс,pickleрезультата и обратно. Работа занимает наносекунды, доставка — десятки микросекунд
Для сравнения та же I/O-задача в asyncio: 8 корутин с await asyncio.sleep(0.5) заняли 0,50 с, 10 тысяч корутин — 0,58 с. ThreadPoolExecutor(1000) на 10 тысячах таких задач потратил 5,16 с, потому что больше 1000 ожиданий одновременно он не держит
Почему процессы замедляют короткую задачу
У процесса три источника накладных расходов:
- Старт. На той же машине пустой процесс стартовал за 44 мс через
spawn, 11 мс черезforkserverи 2 мс черезfork.spawnзапускает новый интерпретатор и заново импортирует твой модуль со всеми зависимостями, поэтому чем тяжелее импорты, тем дольше старт - Сериализация. Аргументы и результат проходят через
pickle. Список из 5 млн чиселsumпосчитал в своём процессе за 0,02 с, а отправка того же списка в уже запущенный воркер пула и подсчёт там заняли 0,15–0,18 с - Дробление. У
Executor.mapпо умолчаниюchunksize=1: каждый элемент — отдельная пересылка. Параметр работает только уProcessPoolExecutor, у потоков и интерпретаторов он ни на что не влияет. Уmultiprocessing.Pool.mapразмер куска считается автоматически, и документация советует для длинных последовательностейimapс явнымchunksize
Процессы окупаются, когда задача считает дольше, чем стоит доставка её данных. Мелкие задачи собирай в пачки через chunksize, вместо больших данных передавай путь к файлу или диапазон индексов
Методы старта: fork, spawn, forkserver
| Метод | Как работает | Где по умолчанию |
|---|---|---|
fork | копия текущего процесса через os.fork(), ребёнок наследует всю память | был умолчанием на Linux до 3.13 включительно. С 3.14 не умолчание нигде |
spawn | чистый интерпретатор, который импортирует твой главный модуль и получает функцию с аргументами через pickle | macOS с 3.8, Windows всегда (там других нет) |
forkserver | при первом запуске стартует однопоточный сервер-процесс, новые воркеры форкаются от него | Linux и другие POSIX, кроме macOS, с 3.14 |
fork опасен с потоками. fork копирует память целиком, но из потоков в ребёнке остаётся только тот, что вызвал fork. Если в этот момент другой поток держал замок, ребёнок получает замок в закрытом состоянии, а открыть его некому. Это касается не только твоих Lock: замки есть внутри logging, внутри аллокатора памяти, внутри драйверов. Документация os.fork прямо говорит, что смешивать потоки и fork на POSIX не было безопасно никогда
Python · Ребёнок после fork навсегда ждёт замок
import multiprocessing as mp, threading, time
lock = threading.Lock()
def holder():
with lock: # фоновый поток держит замок секунду
time.sleep(1)
def child():
with lock: # в копии замок закрыт, а потока-владельца нет
print("ребёнок взял замок")
if __name__ == "__main__":
threading.Thread(target=holder).start()
time.sleep(0.1)
p = mp.get_context("fork").Process(target=child)
p.start()
p.join(timeout=3)
print("ребёнок жив через 3 с:", p.is_alive())
p.kill()На 3.13 скрипт печатает ребёнок жив через 3 с: True, хотя в родителе замок освободился через секунду. С get_context("spawn") ребёнок сразу пишет «ребёнок взял замок»: у него свой новый замок. С 3.12 os.fork() в многопоточном процессе выдаёт DeprecationWarning: This process ... is multi-threaded, use of fork() may lead to deadlocks in the child. Увидеть его можно с флагом -W default, по умолчанию такие предупреждения из библиотек скрыты
Поэтому в 3.14 умолчание на Linux сменили на forkserver: сервер однопоточный, форкать его безопасно, а старт быстрее, чем у spawn. Нужен именно fork — укажи явно: mp.get_context("fork") или ProcessPoolExecutor(mp_context=mp.get_context("fork"))
Зачем if __name__ == "__main__"
При spawn и forkserver ребёнок импортирует твой главный модуль, чтобы найти в нём функцию. Если создание пула стоит на верхнем уровне файла, ребёнок при импорте снова попытается создать пул. На macOS такой скрипт падает с RuntimeError: An attempt has been made to start a new process before the current process has finished its bootstrapping phase, а пул в родителе — с BrokenProcessPool. Защита — весь запуск под if __name__ == "__main__":, а функции для воркеров на верхнем уровне модуля
Из того же механизма следует второе ограничение: всё, что уходит в процесс, должно пройти через pickle. Лямбду в ProcessPoolExecutor не отправить, submit(lambda x: x * 2, 21) падает с PicklingError: Can't pickle <function <lambda>>. Соединение с базой тоже не передать
⚠️ Где ошибаются
Пул процессов на мелких задачах. ex.map(parse_line, lines) на миллионе строк с chunksize по умолчанию тратит почти всё время на пересылку. Укрупняй задачи или передавай пачки
Потоки для CPU-кода в обычной сборке. Восемь потоков на подсчёте статистики загружают одно ядро. Нужны процессы, субинтерпретаторы или free-threaded сборка
Блокирующий вызов в корутине. requests.get внутри async def останавливает весь event loop, подробно — на странице про блокирующий код в async
Код, который работал на Linux и сломался на 3.14 или на macOS. Он полагался на fork: воркер читал глобальную переменную, которую родитель заполнил после импорта. При spawn и forkserver ребёнок видит только результат импорта модуля и аргументы. Передавай данные явно или через initializer пула
🎯 Вопросы с собеседований
Процесс, поток, корутина (зелёный поток): в чём разница
Процесс — изолированная память и свой интерпретатор, данные между процессами копируются, зато CPU-код идёт на разных ядрах. Поток живёт в процессе и делит с соседями память, переключает его ОС в любой момент, поэтому нужны блокировки, а в обычном CPython параллельно работает только ожидание. Корутина — функция, которая приостанавливается на await, все корутины идут в одном потоке, и переключает их event loop только в точках await. Зелёные потоки вроде gevent тоже живут в одном потоке, но переключаются неявно, на I/O-вызовах пропатченных библиотек, а в asyncio каждая точка переключения видна в коде. Корутины стоят дешевле всего: 10 тысяч одновременных ожиданий — обычная нагрузка
CPU-bound против I/O-bound: что выбрать для каждой задачи и почему
CPU-bound задача упирается в вычисления, ей нужны ядра: ProcessPoolExecutor, с 3.14 InterpreterPoolExecutor или C-код, который отпускает GIL. I/O-bound задача упирается в ожидание: для синхронных библиотек хватит ThreadPoolExecutor, для тысяч соединений лучше asyncio, где ожидание стоит почти ничего. Потоки на CPU не помогают из-за GIL, это подробно на странице про GIL. Смешанный сервис обычно делают асинхронным, а тяжёлые вычисления выносят в пул процессов через run_in_executor
Почему создание процессов может замедлить CPU-задачу
У процесса три накладных расхода. Старт: spawn запускает новый интерпретатор и заново импортирует модуль, это десятки миллисекунд, а с тяжёлыми зависимостями и больше. Сериализация: аргументы и результат проходят через pickle и трубу, большой список дороже передать, чем посчитать. Дробление: Executor.map по умолчанию отправляет каждый элемент отдельной задачей, и на 100 тысячах мелких вызовов пул может оказаться в сотни раз медленнее цикла. Лечится через chunksize, крупные задачи и передачу ссылок на данные вместо самих данных
Чем fork отличается от spawn и forkserver
fork копирует текущий процесс: старт быстрый, память наследуется, но из потоков остаётся только вызвавший, и замки, которые держали другие потоки, в ребёнке закрыты навсегда. spawn запускает чистый интерпретатор, импортирует главный модуль и получает функцию с аргументами через pickle: безопасно, но медленно, и нужен if __name__ == "__main__". forkserver один раз запускает однопоточный сервер и форкает воркеров от него: безопасно и быстрее spawn. По умолчанию macOS и Windows используют spawn, Linux с 3.14 использует forkserver, а до этого был fork
Что такое concurrent.futures и чем Executor удобнее голых Thread/Process
Это общий интерфейс над пулами потоков, процессов и с 3.14 субинтерпретаторов. submit возвращает Future: result() отдаёт значение или перебрасывает исключение из воркера. map сохраняет порядок, as_completed отдаёт результаты по готовности, а with закрывает пул и ждёт задачи. С голым Thread результат приходится собирать через очередь, а исключение печатается и теряется. Сменить потоки на процессы — значит заменить один класс
📚 Что почитать
- concurrent.futures — все три Executor,
chunksizeиbuffersizeиз 3.14 - multiprocessing: Contexts and start methods — fork, spawn и forkserver из первых рук
- What's New in Python 3.14 — смена метода старта на Linux и
InterpreterPoolExecutor - Домклик о многопоточности и asyncio — потоки, процессы и asyncio на русском