Introduction

The event loop is the core mechanism that powers asynchronous programming. It is a continuously running loop that waits for events (like a network response, a timer firing, or a file finishing reading) and then runs the callbacks or coroutines associated with them. Instead of blocking a thread while waiting, the event loop lets that thread do other useful work, making it possible to handle many concurrent operations efficiently on a single thread.

Real-World Analogy

Prerequisites

How the Event Loop Works

1. Code runs on the call stack until it hits an async operation (I/O, timer, network).
2. The async operation is handed off to the runtime/OS and the thread keeps going — it does not wait.
3. When that operation completes, its callback/continuation is placed into a queue.
4. The event loop checks: "Is the call stack empty?" If yes, it takes the next item from the queue.
5. That callback runs, possibly starting more async work, and the cycle repeats — forever, until there's nothing left.

Core Components

Event Loop in JavaScript

JavaScript is single-threaded, and its event loop coordinates the call stack, microtasks, and macrotasks.

console.log("1: Start");

setTimeout(() => {
    console.log("4: Timeout (macrotask)");
}, 0);

Promise.resolve().then(() => {
    console.log("3: Promise (microtask)");
});

console.log("2: End");

// Output order:
// 1: Start
// 2: End
// 3: Promise (microtask)   <- microtasks run before macrotasks
// 4: Timeout (macrotask)

Event Loop in Python (asyncio)

In Python, asyncio provides the event loop. asyncio.run() creates it, runs your coroutine, and closes it.

import asyncio

async def say(msg, delay):
    await asyncio.sleep(delay)   # yields control back to the loop
    print(msg)

async def main():
    # The loop interleaves these while each one "sleeps"
    await asyncio.gather(
        say("World", 2),
        say("Hello", 1),
    )

asyncio.run(main())

# Output:
# Hello   (after 1s)
# World   (after 2s)

Accessing the loop directly

import asyncio

async def main():
    loop = asyncio.get_running_loop()
    print("Loop is running:", loop.is_running())
    # Schedule a plain function on the loop
    loop.call_soon(lambda: print("Called soon!"))
    await asyncio.sleep(0)   # let the loop process it

asyncio.run(main())

Microtasks vs Macrotasks

Node.js Event Loop Phases

Node.js (built on libuv) runs its event loop through ordered phases on each iteration (a "tick"):

Why One Thread Handles So Much

With blocking threads, handling \(N\) concurrent connections needs \(N\) threads, costing memory \(N \times M_t\). An event loop uses one thread and only tracks lightweight callbacks, so its memory scales as:

\[ \text{Mem}_{\text{loop}} = M_{\text{base}} + N \times M_{cb} \qquad\text{where}\qquad M_{cb} \ll M_t \]

Since a callback footprint \(M_{cb}\) is tiny compared to a thread stack \(M_t\), one event loop can serve tens of thousands of connections.

The Golden Rule: Never Block the Loop

Best Practices

Common Mistakes

Interview Questions

Quick Revision