Explain async models: callbacks, promises, async/await, and the event loop.

Question

IT Interview Practice · Accepted Answer

**These are progressively nicer ways to express non-blocking work on a single thread, all driven underneath by an event loop that runs ready callbacks one at a time.** They manage *when* code resumes, not multiple threads.

## The event loop

A single-threaded loop maintains a queue of ready callbacks. When an async operation (timer, I/O) completes, its callback is enqueued; the loop picks the next one and runs it to completion, then repeats. Nothing preempts a running callback, so long CPU work blocks everything.

```text
[event loop] → run callback → I/O finishes → enqueue callback → run next → ...
```

## The three styles

```js
// 1. Callbacks — nesting gets ugly ("callback hell")
readFile('a', (e, a) => readFile('b', (e, b) => done(a, b)));

// 2. Promises — chainable, flat error handling
readFile('a').then(a => readFile('b')).then(b => ...).catch(err => ...);

// 3. async/await — sequential-looking, still non-blocking
async function run() {
  const a = await readFile('a');   // yields to the loop while waiting
  const b = await readFile('b');
  return done(a, b);
}
```

`await` suspends the function and returns control to the event loop; when the promise resolves, execution resumes where it left off. It's syntactic sugar over promises — same event loop underneath.

## Why it matters

This model powers Node.js, browsers, and Python asyncio: massive I/O concurrency on one thread with no lock complexity. The catch is you must never block the loop — a synchronous CPU-heavy or blocking call stalls every pending task. Understanding that async ≠ parallel is a common interview discriminator.

The event loop

The three styles

Why it matters

Related questions