This article is only available in Spanish.
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
ArrayBuffero usaSharedArrayBuffer.
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.