Python's asyncio module implements asynchronous programming using a single-threaded approach, which fundamentally differs from traditional multi-threading paradigms.

With only one thread, multiple tasks cannot run simultaneously. Instead, asyncio employs cooperative multitasking, where asynchronous tasks voluntarily yield control to other tasks, allowing them to execute. Once those tasks complete, the original task resumes execution from where it left off.

The asyncio module initiates an event loop within a single thread, continuously monitoring and processing incoming events until all asynchronous tasks conclude.

What is an Event Loop?

In a single-threaded environment, tasks must execute sequentially - one after another. For CPU-intensive operations, this approach functions adequately. However, when dealing with I/O-intensive tasks such as waiting for network responses or disk operations, this sequential method becomes inefficient as the CPU remains idle while waiting for these operations to complete.

Is there a way to optimize single-threaded task execution? Yes - we can temporarily suspend tasks that require I/O operations. When all tasks are in this suspended state, the single thread can begin its continuous cycle: checking for any completed tasks.

When a task completes, it generates a result and signals completion. The event loop, which has been monitoring for such signals, responds by checking if the completed task has any associated callback functions. If callbacks exist, they execute. Otherwise, the task resumes execution with its results.

Implementation Example

import asyncio
import time

async def fetch_webpage(url, identifier):
    print(f"{identifier} is fetching content from {url}")
    await asyncio.sleep(2)
    print(f"{identifier} has completed fetching from {url}")

if __name__ == '__main__':
    start_time = time.time()
    event_loop = asyncio.get_event_loop()
    
    # Create multiple coroutine tasks
    webpage_tasks = [
        fetch_webpage("https://www.example.com", "Task 1"),
        fetch_webpage("https://www.python.org", "Task 2"),
    ]
    
    # Execute all tasks concurrently in the event loop
    event_loop.run_until_complete(asyncio.wait(webpage_tasks))
    end_time = time.time()
    print(f"Total execution time: {end_time - start_time} seconds")

Execution Output

Task 2 is fetching content from https://www.python.org
Task 1 is fetching content from https://www.example.com
Task 2 has completed fetching from https://www.python.org
Task 1 has completed fetching from https://www.example.com
Total execution time: 2.002145767211914 seconds