Concurrencia y subprocesamiento múltiple en TypeScript: nivel avanzado

Concurrencia y subprocesamiento múltiple en TypeScript: nivel avanzado

En el desarrollo web moderno y la programación de servidores, el rendimiento y la capacidad de respuesta de las aplicaciones son críticos. TypeScript, como superconjunto de JavaScript, heredó su modelo de ejecución de un solo hilo (Event Loop). Sin embargo, para resolver tareas que consumen muchos recursos (procesamiento de imágenes, criptografía, cálculos complejos), la asincronía por sí sola no es suficiente. A nivel avanzado, el desarrollador debe comprender cómo organizar un verdadero subprocesamiento múltiple y un trabajo seguro con memoria compartida. En este artículo, analizaremos los mecanismos clave: Web Workers (navegador), Worker Threads (Node.js), SharedArrayBuffer y Atomics.

1. Web Workers: paralelismo en el navegador

Web Workers son la forma principal de ejecutar código en un hilo separado en el entorno del navegador. Un Worker no tiene acceso al DOM, pero puede realizar cálculos pesados sin bloquear el hilo principal (UI).

Crear un Worker en TypeScript requiere compilar un archivo separado. Veamos un ejemplo: cálculo de grandes números de Fibonacci.

Archivo worker.ts (se compila a worker.js):

// worker.ts\nself.onmessage = (event: MessageEvent<number>) => {\n  const n = event.data;\n  const fib = (num: number): number => {\n    if (num <= 1) return num;\n    return fib(num - 1) + fib(num - 2);\n  };\n  const result = fib(n);\n  self.postMessage(result);\n};

Archivo main.ts:

// main.ts\nconst worker = new Worker(new URL('./worker.js', import.meta.url));\n\nworker.postMessage(40);\n\nworker.onmessage = (event: MessageEvent<number>) => {\n  console.log(`Resultado: ${event.data}`); // Salida después de completar\n  worker.terminate();\n};\n\nworker.onerror = (error) => {\n  console.error('Error del Worker:', error.message);\n};

Matices importantes:

\n
• El Worker se ejecuta en un hilo separado, pero no tiene acceso a las variables globales del hilo principal.
\n
• La transferencia de datos se realiza mediante copia (clonación estructurada). Para datos grandes, use Transferable objects (por ejemplo, ArrayBuffer).
\n
• Para TypeScript, es obligatorio especificar los tipos en los mensajes para evitar errores en tiempo de ejecución.
\n

2. Worker Threads: subprocesamiento múltiple en Node.js

Para el entorno de servidor Node.js, el equivalente de Web Workers es el módulo worker_threads. Permite crear hilos aislados con su propia memoria (V8 isolate). Esto es ideal para operaciones intensivas de CPU, como hash o análisis de JSON.

Ejemplo: creación de un Worker para hash de contraseña (worker.ts):

// crypto-worker.ts\nimport { parentPort, workerData } from 'worker_threads';\nimport { createHash } from 'crypto';\n\nif (parentPort) {\n  const { password, salt } = workerData;\n  const hash = createHash('sha256')\n    .update(password + salt)\n    .digest('hex');\n  parentPort.postMessage(hash);\n}

Archivo principal (main.ts):

// main.ts\nimport { Worker } from 'worker_threads';\nimport path from 'path';\n\nfunction hashPassword(password: string, salt: string): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const worker = new Worker(path.resolve(__dirname, 'crypto-worker.js'), {\n      workerData: { password, salt }\n    });\n\n    worker.on('message', resolve);\n    worker.on('error', reject);\n    worker.on('exit', (code) => {\n      if (code !== 0) reject(new Error(`Worker terminó con código ${code}`));\n    });\n  });\n}\n\n(async () => {\n  const hash = await hashPassword('mySecret', 'randomSalt');\n  console.log(`Hash: ${hash}`);\n})();

Diferencias clave con Web Workers:

\n
• Funciona en Node.js, con acceso al sistema de archivos y al proceso.
\n
• Transferencia de datos a través de