Асинхронные функции в Python, основанные на asyncio, используют один поток выполнения. Когда в асинхронной функции производятся длительные синхронные вычисления с большими значениями, они блокируют этот единственный поток. Это означает, что другие асинхронные задачи, ожидающие выполнения, не могут быть запущены до завершения текущего вычисления. Таким образом, асинхронность теряет свое главное преимущество - способность эффективно обрабатывать множество независимых I/O-связанных операций concurrently.

Для выполнения CPU-bound задач (нагружающих процессор), таких как вычисления с большими значениями, более эффективным подходом является использование многопоточности или многопроцессорности.

Многопоточность (Threading) подходит для задач, которые в основном ждут I/O (чтения из файла, сетевые операции). Для CPU-bound задач в Python она ограничена из-за Global Interpreter Lock (GIL), который позволяет выполнять только один поток Python в любой момент времени.
Многопроцессорность (Multiprocessing) создает отдельные процессы, каждый со своим интерпретатором Python и памятью. Это позволяет параллельно выполнять CPU-bound задачи, используя несколько ядер процессора.

Пример неэффективного использования асинхронности для вычислений:

import asyncio
import time

async def compute_heavy(n):
    # Имитация тяжелых вычислений
    result = 0
    for i in range(n):
        result += i * i
    print(f"Computation finished with result: {result}")
    return result

async def main():
    start_time = time.time()
    # Вызов блокирующей задачи в асинхронной функции
    await compute_heavy(10**7)
    end_time = time.time()
    print(f"Total time: {end_time - start_time:.2f} seconds")

# В этом случае асинхронность не дает выигрыша, т.к. compute_heavy блокирует основной цикл событий.
# Если бы здесь были другие I/O-связанные задачи, они бы ждали завершения compute_heavy.

Чтобы сделать вычисления эффективными в контексте асинхронности или использовать их совместно с async/await для I/O задач, можно использовать loop.run_in_executor(). Это позволяет выполнять блокирующие функции в отдельном потоке или процессе, не блокируя основной цикл событий.

import asyncio
import time
from concurrent.futures import ProcessPoolExecutor # Или ThreadPoolExecutor

async def compute_heavy(n):
    # Имитация тяжелых вычислений
    result = 0
    for i in range(n):
        result += i * i
    return result

async def main():
    start_time = time.time()
    loop = asyncio.get_event_loop()
    
    # Используем ProcessPoolExecutor для выполнения CPU-bound задачи
    # Можно использовать ThreadPoolExecutor, но для CPU-bound задач ProcessPoolExecutor предпочтительнее
    with ProcessPoolExecutor() as executor:
        # Передаем блокирующую функцию в executor, чтобы она выполнилась в отдельном процессе
        result = await loop.run_in_executor(executor, compute_heavy, 10**7)
        print(f"Computation finished with result: {result}")
    
    end_time = time.time()
    print(f"Total time: {end_time - start_time:.2f} seconds")

# Этот подход позволяет не блокировать основной цикл событий asyncio
# и выполнять другие асинхронные задачи одновременно с вычислениями.

# asyncio.run(main()) # Для запуска в Python 3.7+

Таким образом, выполнения вычислений с большими значениями непосредственно в асинхронной функции блокирует цикл событий, делая асинхронность неэффективной. Для таких задач следует использовать многопоточность или многопроцессорность, интегрируя их с асинхронностью через исполнители (executors).

Почему выполнение вычислений с большими значениями в асинхронной функции может быть неэффективным?