Saltar al contenido
JavaScript en el servidor

El event loop de Node

Lección 2 de 712 min3 ejercicios

En la sección de Asincronía viste el event loop del navegador. El de Node.js sigue la misma idea, pero con más detalle: un recorrido por fases, cada una con su propia cola, más dos colas prioritarias. Saber en qué fase corre cada callback explica comportamientos que de otra forma parecen aleatorios.

Qué mirar en el pizarrón

Fíjate en las notas de cada tarjeta: en qué fase espera cada callback. Y en cuándo se vacían las colas de nextTick y de microtareas: entre un callback y otro.

En el pizarrón

const fs = require("node:fs"); fs.readFile(__filename, () => {  setTimeout(() => console.log("timeout"), 0);  setImmediate(() => console.log("immediate"));  process.nextTick(() => console.log("nextTick"));}); Promise.resolve().then(() => console.log("promesa"));process.nextTick(() => console.log("nextTick 1"));console.log("síncrono");

Pila, APIs y colas

  1. programa principalcorre entero
  2. leer el archivolibuv, en otro hilo
  3. nextTick 1cola de nextTick
  4. promesacola de microtareas
Consolasíncrono

Corre todo el programa principal. La lectura del archivo se delega en libuv, la librería que hace el trabajo de entrada y salida. Se agendan un nextTick y una promesa.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: Corre todo el programa principal. La lectura del archivo se delega en libuv, la librería que hace el trabajo de entrada y salida. Se agendan un nextTick y una promesa. Estado: pila: programa principal corre entero, Web API: leer el archivo libuv, en otro hilo, microtareas: nextTick 1 cola de nextTick, microtareas: promesa cola de microtareas.
  2. Paso 2: Al terminar el código, Node.js vacía primero la cola de process.nextTick, propia de Node… Estado: pila: nextTick 1 true, Web API: leer el archivo libuv, en otro hilo, microtareas: promesa cola de microtareas.
  3. Paso 3: …y después la de microtareas: las promesas. Recién entonces entra en las fases del event loop. Estado: pila: promesa true, Web API: leer el archivo libuv, en otro hilo.
  4. Paso 4: El event loop de Node recorre fases: timers, poll (entrada y salida), check (setImmediate)… Cuando el archivo está leído, su callback corre en la fase poll y agenda tres cosas, cada una en su lugar. Estado: pila: callback de readFile fase poll, cola de tareas: () => console.log("timeout") fase timers, cola de tareas: () => console.log("immediate") fase check, microtareas: nextTick cola de nextTick.
  5. Paso 5: Después de cada callback, antes de seguir con la fase, se vacían las colas de nextTick y de microtareas. Estado: pila: nextTick true, cola de tareas: () => console.log("timeout") fase timers, cola de tareas: () => console.log("immediate") fase check.
  6. Paso 6: Después de poll viene la fase check: corre el setImmediate. El temporizador tiene que esperar a que el loop dé la vuelta y vuelva a la fase timers. Estado: pila: immediate fase check, cola de tareas: () => console.log("timeout") fase timers, en la próxima vuelta.
  7. Paso 7: Nueva vuelta, fase timers: corre el setTimeout. Estado: pila: timeout fase timers.
  8. Paso 8: No queda nada pendiente: ni temporizadores, ni lecturas, ni conexiones. Node.js termina el proceso. Un servidor no termina nunca porque siempre tiene una conexión escuchando. Estado: todo vacío.

libuv

Tu JavaScript corre en un solo hilo, pero Node.js no hace todo en ese hilo. libuv, la librería en C que está debajo, se encarga de la entrada y salida:

  • La red la atiende el sistema operativo, que avisa cuando hay datos.
  • Los archivos, la criptografía pesada y la compresión los hace un grupo de hilos auxiliares (cuatro por defecto).

Cuando una operación termina, libuv deja su callback en la cola de la fase que corresponde.

Las fases

Cada vuelta del event loop recorre estas fases, en orden:

Fase Qué callbacks corren
timers Los de setTimeout y setInterval cuyo tiempo venció
pending callbacks Algunos errores de sistema que quedaron pendientes
poll Los de entrada y salida: datos de red, archivos leídos… Si no hay nada que hacer, el loop espera aquí
check Los de setImmediate
close Los de cierre, como socket.on("close")

Y entre cada callback, de cualquier fase, Node.js vacía dos colas prioritarias:

  1. La de process.nextTick.
  2. La de microtareas: promesas y queueMicrotask.

setImmediate o setTimeout

Como muestra el pizarrón, dentro de un callback de entrada y salida, setImmediate corre antes que setTimeout(…, 0): la fase check viene justo después de poll, y timers espera a la vuelta siguiente.

Desde el programa principal, en cambio, el orden entre los dos no está garantizado: depende de cuánto tardó el loop en arrancar. No escribas código que dependa de ese orden.

nextTick: con cuidado

process.nextTick(fn) corre fn apenas termine la operación actual, antes que cualquier promesa y que cualquier fase. Se usa, por ejemplo, para que una función siempre llame a su callback de forma asíncrona.

Pero su prioridad es un arma de doble filo: un nextTick que se agenda a sí mismo en bucle nunca deja avanzar al event loop. Para “hacer algo después”, prefiere setImmediate o queueMicrotask.

No bloquees el hilo

En un servidor, el único hilo atiende todas las peticiones. Si una petición hace algo síncrono y lento, las demás esperan:

import http from "node:http";
import { readFileSync } from "node:fs";
import { readFile } from "node:fs/promises";

http.createServer(async (req, res) => {
  // ✗ Bloquea: mientras lee, nadie más es atendido
  // const html = readFileSync("pagina.html", "utf8");

  // ✓ No bloquea: libuv lee el archivo y el hilo sigue atendiendo
  const html = await readFile("pagina.html", "utf8");
  res.end(html);
}).listen(3000);

Lo mismo con cálculos pesados (cifrar, comprimir, procesar imágenes, un JSON enorme): o las versiones asíncronas de Node, o un worker thread, el próximo tema.

Resumen

  • libuv hace la entrada y salida (la red con el sistema operativo y los archivos con un grupo de hilos) y avisa con callbacks.
  • El loop recorre fases: timers → poll → check → close.
  • Entre cada callback se vacían la cola de nextTick y, después, la de microtareas.
  • Dentro de un callback de I/O, setImmediate gana a setTimeout(…, 0); desde el programa principal, el orden no está garantizado.
  • Nunca bloquees el hilo en un servidor: usa las APIs asíncronas o workers.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Fases y colas

Elige una respuesta en cada pregunta.

  1. ¿Quién hace el trabajo de entrada y salida (archivos, red) en Node.js?

  2. ¿Qué corre antes: un callback de process.nextTick o el then de una promesa?

  3. Dentro del callback de una lectura de archivo, ¿qué corre primero, setImmediate o setTimeout(…, 0)?

  4. ¿Por qué un servidor no debe usar fs.readFileSync al atender cada petición?

Ordena la salida: nextTick, promesas e immediate

Las dos colas prioritarias de Node y una fase. Ordena lo que aparecería en la terminal.

// orden.cjs: un archivo CommonJSsetImmediate(() => console.log("immediate")); Promise.resolve().then(() => console.log("promesa"));process.nextTick(() => console.log("nextTick")); queueMicrotask(() => {  console.log("microtarea");  process.nextTick(() => console.log("nextTick desde una microtarea"));}); console.log("síncrono");

Consola, de arriba abajo

  1. nextTick desde una microtarea
  2. promesa
  3. síncrono
  4. immediate
  5. microtarea
  6. nextTick

Detective: Un rechazo que tumba el servidor

Un servidor se cae una vez por hora, cuando el inventario no responde. Encuentra la línea y elige el arreglo.

Consola

node:internal/process/promises:394
    triggerUncaughtException(err, true /* fromPromise */);
    ^

Error: falló la consulta de stock
    at consultarStock (file:///proyecto/stock.mjs:3:22)

Node.js v24.11.0

Paso 1: toca la línea de código que causa el error.

domina-js · JavaScript en español, gratis y paso a paso.