Почему асинхронность в Python не подходит для CPU-bound задач?

А, слушай, смотри, вот эта вся асинхронность в Питоне, с этими asyncio — это ж, блядь, чисто для задач, где ты нихуя не делаешь, а просто ждёшь! Ну, типа, сетевой запрос пошёл, файл читается, база данных ковыряется в своём дупе. Ты в это время можешь другую задачку запустить, пока первая там, в рот меня чих-пых, тормозит. Это называется I/O-bound, если по-умному.

А вот если у тебя задача CPU-bound — ну, там, числа перемножать до посинения, хеши считать, нейросеть обучать — то тут асинхронность нихуя не поможет, и вот почему, блядь:

1. Глобальная Блокировка Интерпретатора (GIL), ёпта! Эта сука не даёт в одном процессе больше одного потока питоньего кода выполняться одновременно. Асинхронность-то работает в одном потоке! Она просто между задачами перепрыгивает, пока одна ждёт. А если задачи не ждут, а считают — так они и будут сидеть в одной очереди к процессору, как дурачки, по одной. Несколько ядер? Да похуй! GIL не пустит.

2. Конкурентность, а не параллелизм, блядь! Асинхронность — это как один официант, который ловко перебегает между десятью столиками. Быстро, эффективно. А CPU-bound задачи — это как десять жирных клиентов, которые заказали по три стейка каждый, и их надо одновременно жевать. Одному официанту нихуя не сделать, нужны десять поваров (ядер процессора), которые будут их параллельно готовить.

3. Event Loop встаёт колом! Представь: запустил ты в своей асинхронной функции, блядь, цикл на миллион итераций без единого await. И всё, пиздец. Весь этот твой хваленый event loop встаёт, как вкопанный, и ждёт, пока эта вычислительная мастодонтка не кончит. Все остальные задачи — даже те, которые просто файлик прочитать хотели — будут тупо проёбывать время. Зачем тогда вообще асинхронность, спрашивается?

Смотри, пример, чтобы совсем понятно стало:

import asyncio
import time
from multiprocessing import Pool

# ПЛОХОЙ ПРИМЕР. CPU-bound задача в асинхронной функции.
async def cpu_bound_task_async(name, num):
    print(f"[{name}] Начало CPU-bound задачи...")
    start_time = time.time()
    result = sum(i*i for i in range(num)) # Вот эта хуйня будет блокировать всё!
    end_time = time.time()
    print(f"[{name}] Завершение CPU-bound задачи за {end_time - start_time:.2f} сек. Результат: {result % 1000}")
    return result

async def main_bad():
    print("--- Запуск с блокирующей асинхронной задачей ---")
    await asyncio.gather(
        cpu_bound_task_async("Task A", 10**7),
        cpu_bound_task_async("Task B", 10**7)
    )
    print("--- Завершение блокирующей асинхронной задачи ---")

# asyncio.run(main_bad()) # Раскомментируй и посмотри, как они выполнятся ПО ОЧЕРЕДИ, а не вместе.

Видишь? Они ж будут выполняться одна за другой, сука! Вторая начнёт только когда первая всю свою математику закончит. Это пиздец как неэффективно.

А вот как надо, блядь:

# ХОРОШО. Выносим тяжёлые вычисления в отдельные процессы.
def _cpu_bound_worker(num):
    return sum(i*i for i in range(num))

async def cpu_bound_task_multiprocess(name, num):
    print(f"[{name}] Начало CPU-bound задачи через multiprocessing...")
    start_time = time.time()
    with Pool() as pool:
        # asyncio.to_thread — чтоб не блокировать event loop, пока процессы там ебутся.
        result = await asyncio.to_thread(pool.apply, _cpu_bound_worker, (num,))
    end_time = time.time()
    print(f"[{name}] Завершение CPU-bound задачи через multiprocessing за {end_time - start_time:.2f} сек. Результат: {result % 1000}")
    return result

async def main_good():
    print("n--- Запуск с CPU-bound задачей через multiprocessing ---")
    await asyncio.gather(
        cpu_bound_task_multiprocess("Task C", 10**7),
        cpu_bound_task_multiprocess("Task D", 10**7)
    )
    print("--- Завершение CPU-bound задачи через multiprocessing ---")

# asyncio.run(main_good()) # А вот тут они уже реально ПАРАЛЛЕЛЬНО попрут на разных ядрах!

Итог, ёпта:

• Для I/O (ждём) — asyncio, красота.
• Для CPU (считаем) — multiprocessing или что-то подобное. Каждый процесс — свой GIL, свои ядра, полный улёт.
• Можно на Си написать расширение, которое GIL обходит.
• asyncio.to_thread — тоже вариант, чтобы основную петлю не блокировать, но это так, полумера, если GIL не сильно мешает.

Короче, не пытайся асинхронностью гвозди забивать, для этого есть другие инструменты, блядь.