Volver al blog

Worker Threads vs async en Node.js: la verdad sobre el rendimiento

Tienes un endpoint que genera un informe y, mientras lo calcula, toda la API deja de responder. Le pones async a la función y sigue igual. No es mala suerte: async no hace lo que crees.

Concurrencia no es paralelismo

Node.js ejecuta tu JavaScript en un solo hilo, el del event loop.

  • Concurrencia: muchas tareas en marcha a la vez, turnándose. Es lo que da async: mientras una petición espera a la base de datos o a la red, el hilo atiende otras.
  • Paralelismo: varias tareas ejecutándose a la vez en distintos núcleos. Eso no lo da async.

El mito de las funciones async

async function total(items: number[]) {
  let sum = 0;
  for (const n of items) sum += Math.sqrt(n) * Math.log(n + 1);
  return sum;
}

Esta función bloquea el hilo igual que sin async. async solo hace que devuelva una promesa; el bucle sigue ejecutándose de principio a fin sin ceder el turno. Mientras tanto, ninguna otra petición avanza.

async ayuda cuando el trabajo es esperar (I/O). Cuando el trabajo es calcular (CPU), no.

Worker Threads para el cálculo pesado

worker_threads ejecuta JavaScript en otro hilo, con su propio event loop. El hilo principal queda libre.

// main.mjs
import { Worker } from 'node:worker_threads';

export function runReport(items) {
  return new Promise((resolve, reject) => {
    const worker = new Worker(new URL('./report-worker.mjs', import.meta.url), { workerData: items });
    worker.once('message', resolve);
    worker.once('error', reject);
    worker.once('exit', (code) => code !== 0 && reject(new Error(`Worker exited with code ${code}`)));
  });
}
// report-worker.mjs
import { parentPort, workerData } from 'node:worker_threads';

let sum = 0;
for (const n of workerData) sum += Math.sqrt(n) * Math.log(n + 1);
parentPort.postMessage(sum);

Ahora await runReport(items) sí deja que el resto de peticiones sigan respondiendo.

Cuándo no usar Worker Threads

  • Para I/O: leer archivos, consultar la base de datos o llamar a una API ya es asíncrono. Un worker solo añade coste.
  • Para tareas pequeñas: crear un worker tarda y consume memoria. Si lo vas a hacer a menudo, reutiliza hilos con un pool (por ejemplo, la librería piscina) en vez de crear uno por petición.
  • Con datos enormes: lo que envías al worker se copia. Para mucho volumen, transfiere ArrayBuffer o usa SharedArrayBuffer.

Cómo elegir

Tarea Herramienta
Esperar red, disco o base de datos async/await
Cálculo pesado puntual (informes, imágenes, parseo grande) Worker Thread
Cálculo pesado frecuente pool de workers

Y antes de decidir, mide: cronometra la tarea con performance.now() y comprueba si de verdad bloquea el event loop.