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

Python Road Map

🧵 Потоки, процессы и корутины

В 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, ThreadPoolExecutorI/O с синхронными библиотеками: requests, драйвер базы без async, запись файлов. C-код, который отпускает GIL (hashlib, numpy)нет параллелизма на Python-коде, гонки на общих данных, свой стек и планирование ОС на каждый поток
multiprocessing, ProcessPoolExecutorCPU-задача на чистом 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 * x0,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 ожиданий одновременно он не держит

Почему процессы замедляют короткую задачу

У процесса три источника накладных расходов:

  1. Старт. На той же машине пустой процесс стартовал за 44 мс через spawn, 11 мс через forkserver и 2 мс через fork. spawn запускает новый интерпретатор и заново импортирует твой модуль со всеми зависимостями, поэтому чем тяжелее импорты, тем дольше старт
  2. Сериализация. Аргументы и результат проходят через pickle. Список из 5 млн чисел sum посчитал в своём процессе за 0,02 с, а отправка того же списка в уже запущенный воркер пула и подсчёт там заняли 0,15–0,18 с
  3. Дробление. У Executor.map по умолчанию chunksize=1: каждый элемент — отдельная пересылка. Параметр работает только у ProcessPoolExecutor, у потоков и интерпретаторов он ни на что не влияет. У multiprocessing.Pool.map размер куска считается автоматически, и документация советует для длинных последовательностей imap с явным chunksize

Процессы окупаются, когда задача считает дольше, чем стоит доставка её данных. Мелкие задачи собирай в пачки через chunksize, вместо больших данных передавай путь к файлу или диапазон индексов

Методы старта: fork, spawn, forkserver

МетодКак работаетГде по умолчанию
forkкопия текущего процесса через os.fork(), ребёнок наследует всю памятьбыл умолчанием на Linux до 3.13 включительно. С 3.14 не умолчание нигде
spawnчистый интерпретатор, который импортирует твой главный модуль и получает функцию с аргументами через picklemacOS с 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 результат приходится собирать через очередь, а исключение печатается и теряется. Сменить потоки на процессы — значит заменить один класс

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