Что хотят услышать интервьюеры:

Асинхронность хорошо решает задачи, где много ожидания, но почти не ускоряет CPU-bound нагрузку. Если задача долго считает и не отдаёт управление, event loop будет заблокирован, и преимущества async пропадут. Для таких случаев обычно используют multiprocessing, отдельные процессы или вынос вычислений в нативный код.

Определение:

Асинхронное программирование в Python эффективно для I/O-bound задач: сетевых запросов, работы с файлами, ожидания ответов от сервисов. Но при интенсивных вычислениях оно ограничено тем, что в одном потоке event loop выполняет код последовательно. Если корутина долго занимает процессор и не делает await, она мешает выполнению остальных задач.

Дополнительное ограничение в Python связано с GIL: в пределах одного процесса CPU-bound Python-код не может по-настоящему выполняться параллельно в нескольких потоках. Поэтому asyncio не является способом ускорить вычисления.

Пример использования:

Допустим, нужно обработать большой массив данных: посчитать суммы, выполнить фильтрацию и преобразования для тысяч элементов. Если делать это внутри async-функции без await, другие корутины будут ждать завершения вычислений. Для такой задачи лучше вынести расчёты в отдельные процессы.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_compute(n: int) -> int:
    total = 0
    for i in range(n):
        total += i * i
    return total

async def main():
    loop = asyncio.get_running_loop()

    with ProcessPoolExecutor() as pool:
        tasks = [
            loop.run_in_executor(pool, heavy_compute, 10_000_000),
            loop.run_in_executor(pool, heavy_compute, 12_000_000),
        ]
        results = await asyncio.gather(*tasks)
        print(results)

asyncio.run(main())

Пояснение кода:

Код показывает, как не выполнять тяжёлые вычисления прямо в event loop.

heavy_compute() — обычная синхронная функция с интенсивной CPU-нагрузкой.
ProcessPoolExecutor() создаёт пул отдельных процессов.
loop.run_in_executor(...) отправляет вычисления в пул, чтобы не блокировать основной asyncio-цикл.
asyncio.gather(...) ждёт завершения всех задач параллельно.
В результате event loop остаётся отзывчивым, а вычисления распределяются между процессами.

Ключевые моменты:

asyncio полезен для ожидания, а не для ускорения чистых вычислений.
CPU-bound код в корутине блокирует event loop, если не уступает управление.
Потоки в Python не дают полноценного параллелизма для CPU-задач из-за GIL.
Для тяжёлых вычислений обычно используют multiprocessing или ProcessPoolExecutor.
Если возможно, вычисления лучше выносить в C/C++/NumPy/другие нативные библиотеки.

Какие ограничения существуют у асинхронного программирования при выполнении задач, интенсивно использующих процессорные ресурсы?