Common Event Loop Misconceptions in JavaScript

Common Event Loop Misconceptions in JavaScript

The event loop is one of the most misunderstood topics in JavaScript. Here are the common misconceptions and the correct explanations.

Misconception 1: "JavaScript is multi-threaded"

Wrong: JS has multiple queues and Web APIs, so it must be multi-threaded.

Correct: The JS engine has one call stack (one thread). Web APIs may run on separate browser threads, but only one JS statement runs at a time. The event loop moves callbacks to the single stack.

Misconception 2: "setTimeout(cb, 0) runs immediately"

Wrong: 0 delay means the callback runs right away.

Correct: The callback goes to the macrotask queue. The event loop runs it only after the stack is empty and all microtasks are done. It runs after all synchronous code.

Misconception 3: "Promises and setTimeout are the same priority"

Wrong: both are async, so they run in the order they were scheduled.

Correct: Promise callbacks are microtasks; setTimeout callbacks are macrotasks. Microtasks always run before macrotasks, regardless of when they were scheduled.

Misconception 4: "await blocks the main thread"

Wrong: await stops the engine until the promise resolves.

Correct: await pauses the async function and returns control to the caller. The engine continues running other code. The rest of the function runs as a microtask when the promise settles and the stack is empty.

Misconception 5: "The event loop is part of the JS engine"

Wrong: V8 includes the event loop.

Correct: The event loop is part of the host environment (browser or Node.js). V8 provides the call stack and heap. The host provides the event loop, Web APIs, and queues.

Misconception 6: "Async operations run on the main thread"

Wrong: fetch runs on the call stack.

Correct: fetch hands the network request to a Web API (browser thread). Only the .then callback runs on the main thread (call stack) when the response arrives.

Misconception 7: "More microtasks means more parallelism"

Wrong: queuing many promises means they run in parallel.

Correct: Promise callbacks run one at a time on the single call stack. Promise.all starts the operations in parallel (via Web APIs), but the callbacks run sequentially on the main thread.

Misconception 8: "The event loop runs continuously, even when idle"

Wrong: the event loop is always spinning.

Correct: when there is no work (stack empty, queues empty), the event loop waits for new events. It does not spin uselessly. The browser can sleep until an event arrives.

The Takeaway

Common event loop misconceptions: JS is multi-threaded (no, one stack), setTimeout(cb, 0) runs immediately (no, after sync and microtasks), promises and timers have the same priority (no, microtasks first), await blocks (no, it yields), the event loop is part of V8 (no, it is part of the host), async ops run on the main thread (no, on Web API threads).