Leg async-modellen uit: callbacks, promises, async/await en de event loop.

Question

IT Interview Practice · Accepted Answer

**Dit zijn steeds prettigere manieren om non-blocking werk op één thread uit te drukken, allemaal onderliggend aangedreven door een event loop die klaarstaande callbacks één voor één uitvoert.** Ze beheren *wanneer* code hervat, niet meerdere threads.

## De event loop

Een single-threaded lus onderhoudt een queue van klaarstaande callbacks. Wanneer een async-operatie (timer, I/O) voltooit, wordt zijn callback in de queue gezet; de lus pakt de volgende en voert hem tot voltooiing uit, en herhaalt dan. Niets preempteert een lopende callback, dus lang CPU-werk blokkeert alles.

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

## De drie stijlen

```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` schort de functie op en geeft de controle terug aan de event loop; wanneer de promise resolvet, hervat de uitvoering waar hij was gebleven. Het is syntactic sugar bovenop promises — dezelfde event loop eronder.

## Waarom het belangrijk is

Dit model drijft Node.js, browsers en Python asyncio aan: enorme I/O-concurrency op één thread zonder lock-complexiteit. Het addertje is dat je de loop nooit mag blokkeren — een synchrone CPU-zware of blocking call laat elke wachtende taak stilvallen. Begrijpen dat async ≠ parallel is een veelvoorkomende interview-discriminator.

De event loop

De drie stijlen

Waarom het belangrijk is

Gerelateerde vragen