Why might performing calculations with large values…

Asynchronous functions in Python based on asyncio use a single thread of execution. When long-running synchronous computations with large values are performed within an asynchronous function, they block this single thread. This means that other awaiting asynchronous tasks cannot be started until the current computation finishes. Thus, the main advantage of asynchronous programming — the ability to efficiently handle multiple independent I/O-bound operations concurrently — is lost.

For CPU-bound tasks, such as computations with large values, a more effective approach is to use multithreading or multiprocessing.

Multithreading is suitable for tasks that mainly wait for I/O (file reading, network operations). In Python, it is limited for CPU-bound tasks due to the Global Interpreter Lock (GIL), which allows only one Python thread to execute at a time.
Multiprocessing creates separate processes, each with its own Python interpreter and memory space. This allows parallel execution of CPU-bound tasks across multiple processor cores.

Example of inefficient use of asynchronous programming for computations:

import asyncio
import time

async def compute_heavy(n):
    # Simulate heavy computations
    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()
    # Calling a blocking task within an async function
    await compute_heavy(10**7)
    end_time = time.time()
    print(f"Total time: {end_time - start_time:.2f} seconds")

# In this case, asynchrony does not provide a benefit because compute_heavy blocks the main event loop.
# If there were other I/O-bound tasks here, they would wait for compute_heavy to finish.

To make computations efficient within an asynchronous context or to use them together with async/await for I/O tasks, you can use loop.run_in_executor(). This allows executing blocking functions in a separate thread or process without blocking the main event loop.

import asyncio
import time
from concurrent.futures import ProcessPoolExecutor  # Or ThreadPoolExecutor

async def compute_heavy(n):
    # Simulate heavy computations
    result = 0
    for i in range(n):
        result += i * i
    return result

async def main():
    start_time = time.time()
    loop = asyncio.get_event_loop()
    
    # Use ProcessPoolExecutor for CPU-bound tasks
    # ThreadPoolExecutor can be used, but ProcessPoolExecutor is preferable for CPU-bound tasks
    with ProcessPoolExecutor() as executor:
        # Pass the blocking function to the executor to run in a separate process
        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")

# This approach prevents blocking the main asyncio event loop
# and allows other asynchronous tasks to run concurrently with the computations.

# asyncio.run(main()) # For Python 3.7+

Thus, executing large-value computations directly within an asynchronous function blocks the event loop, making asynchrony ineffective. For such tasks, multithreading or multiprocessing should be used, integrated with asynchrony via executors.

Why might performing calculations with large values in an asynchronous function be inefficient?