Когда вы выбираете threading, multiprocessing или asyncio?

Question

Accepted Answer

Python предлагает три модели конкурентности, и правильный выбор зависит в основном от того, является ли ваша работа **ограниченной операциями ввода-вывода** или **ограниченной ЦП** — решение, во многом определяемое GIL (который предотвращает параллельное выполнение потоков кода Python).

## Три модели

```text
threading        → multiple threads, ONE process. GIL-limited for CPU.
multiprocessing  → multiple PROCESSES, each its own interpreter/GIL → true parallelism.
asyncio          → single thread, cooperative coroutines yielding at await points.
```

## threading — для конкурентности с ограничением операций ввода-вывода

```python
from concurrent.futures import ThreadPoolExecutor

# ✅ good for I/O — the GIL is RELEASED during I/O waits, so waits overlap
with ThreadPoolExecutor(max_workers=10) as ex:
    results = list(ex.map(download_url, urls))   # many downloads concurrently
```

Потоки хорошо подходят для задач с ограничением операций ввода-вывода (сетевые операции, файлы, БД), потому что GIL освобождается во время ожидания — несколько операций ожидания происходят конкурентно. Они **не** ускоряют работу, ограниченную ЦП.

## multiprocessing — для параллелизма с ограничением ЦП

```python
from concurrent.futures import ProcessPoolExecutor

# ✅ good for CPU — separate processes each have their own GIL → use all cores
with ProcessPoolExecutor(max_workers=4) as ex:
    results = list(ex.map(heavy_computation, data))   # genuine parallelism
```

Для работы с интенсивным использованием ЦП (обработка изображений, математические вычисления, обработка данных) отдельные процессы обходят единый GIL и работают истинно параллельно на нескольких ядрах. Цена: более высокие накладные расходы (запуск процесса), и данные должны быть **сериализованы** между процессами (нет общей памяти по умолчанию).

## asyncio — для высокой конкурентности операций ввода-вывода

```python
import asyncio
# ✅ best for MANY concurrent I/O operations (thousands) — lightest weight
await asyncio.gather(*(fetch(url) for url in urls))
```

asyncio обрабатывает огромное количество конкурентных операций ввода-вывода в одном потоке более эффективно, чем потоки (нет накладных расходов на один поток) — идеально для серверов и сетевого кода с высокой конкурентностью.

## Руководство по принятию решения

```text
CPU-bound (computation)              → multiprocessing
I/O-bound, moderate concurrency      → threading (simple, works with sync libraries)
I/O-bound, HIGH concurrency          → asyncio (thousands of connections, but needs
                                       async-compatible libraries)
Mixed CPU + I/O                       → combine (e.g. asyncio + a process pool for CPU)
```

## Почему это важно

Выбор правильной модели конкурентности — одно из наиболее важных решений для производительности Python, и неправильный выбор (классическая ошибка: потоки для работы, ограниченной ЦП, что GIL делает бесполезным) приводит к коду, который не масштабируется.

Логика выбора вытекает из GIL: **потоки/asyncio для работы, ограниченной операциями ввода-вывода** (GIL освобождается во время ожидания — конкурентность работает) и **multiprocessing для работы, ограниченной ЦП** (отдельные GIL для настоящего параллелизма), с предпочтением asyncio при очень высокой конкурентности.

Понимание сильных сторон каждой модели, затрат (накладные расходы процесса/сериализация, требования к библиотекам asyncio) и решения о выборе между операциями ввода-вывода и ЦП необходимо для написания конкурентного кода Python, который действительно обеспечивает производительность.