Colas de tareas en TypeScript: creación y optimización del procesamiento

Trabajo con colas de tareas en TypeScript: guía completa

En el desarrollo web moderno y las aplicaciones de servidor, a menudo surge la necesidad de ejecutar tareas de forma asíncrona, en segundo plano o con limitación de paralelismo. Las colas de tareas (task queues) son un patrón potente que permite organizar una ejecución predecible y eficiente de las operaciones. En este artículo, analizaremos en detalle cómo crear y utilizar colas de tareas en TypeScript, desde implementaciones simples hasta técnicas avanzadas con prioridades y manejo de errores.

¿Qué es una cola de tareas y para qué sirve?

Una cola de tareas es una estructura de datos que funciona según el principio FIFO (First In, First Out). Las tareas se añaden al final de la cola y se extraen del principio. En el contexto de TypeScript y Node.js, las colas se utilizan para:

• Limitación de paralelismo — control de la cantidad de operaciones ejecutadas simultáneamente (por ejemplo, solicitudes a API con límites).
• Procesamiento asíncrono — ejecución de tareas pesadas en segundo plano sin bloquear el hilo principal.
• Reintentos — reinicio automático de tareas fallidas con un retardo.
• Gestión del orden — garantía de ejecución secuencial de operaciones dependientes.

TypeScript añade tipado estricto, lo que hace que el código de las colas sea más fiable y predecible.

Implementación básica de una cola de tareas en TypeScript

Empecemos creando una cola simple pero completamente tipada. Esta aceptará tareas (funciones que devuelven una Promise) y las ejecutará secuencialmente.

// Definimos el tipo de tareatype Task<T> = () => Promise<T>;

// Clase de la colaclass TaskQueue<T> {    private queue: Task<T>[] = [];    private isProcessing: boolean = false;

    // Añadir tarea a la cola    enqueue(task: Task<T>): void {        this.queue.push(task);        this.process();    }

    // Iniciar el procesamiento    private async process(): Promise<void> {        if (this.isProcessing) return;        this.isProcessing = true;

        while (this.queue.length > 0) {            const task = this.queue.shift()!;            try {                const result = await task();                console.log('Tarea completada:', result);            } catch (error) {                console.error('Error al ejecutar la tarea:', error);            }        }

        this.isProcessing = false;    }}

// Ejemplo de usoconst queue = new TaskQueue<string>();queue.enqueue(async () => {    await new Promise(resolve => setTimeout(resolve, 1000));    return 'Primera tarea';});queue.enqueue(async () => 'Segunda tarea (rápida)');

Esta implementación garantiza la ejecución secuencial y el inicio automático del procesamiento al añadir una nueva tarea. Sin embargo, no soporta paralelismo ni prioridades.

Cola con limitación de paralelismo

A menudo es necesario ejecutar varias tareas simultáneamente, pero sin exceder un cierto límite (por ejemplo, 5 solicitudes paralelas). Añadamos el parámetro concurrency.

class ParallelTaskQueue<T> {    private queue: Task<T>[] = [];    private activeCount: number = 0;    private readonly concurrency: number;

    constructor(concurrency: number = 3) {        this.concurrency = concurrency;    }

    enqueue(task: Task<T>): void {        this.queue.push(task);        this.processNext();    }

    private processNext(): void {        while (this.activeCount < this.concurrency && this.queue.length > 0) {            const task = this.queue.shift()!;            this.activeCount++;            task()                .then(result => console.log('Éxito:', result))                .catch(error => console.error('Error:', error))                .finally((
```