E3: pool/cola de Promises (concurrencia asíncrona)
Ejecute muchas tareas asíncronas con un límite pequeño de concurrencia. Mantenga una cola, inicie varias a la vez y recopile los resultados.
E3: pool/cola de Promises (concurrencia asíncrona) es una lección gratuita de JavaScript Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de JavaScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de JavaScript Academy incluye 3 lecciones en total.
Qué haremos y por qué
Objetivo: ejecutar muchos trabajos asíncronos sin saturar el sistema.
- Limite la concurrencia (por ejemplo, 2 a la vez)
- Mantenga un índice de cola sencillo
- Guarde los resultados en un arreglo
- Escriba código fácil para principiantes, con ayudantes pequeños
Ayudante para trabajos asíncronos
Un ayudante pequeño devuelve una Promise que se resuelve después de un retraso y que puede fallar opcionalmente para realizar pruebas.
// Simulate async work with setTimeout
function fakeJob(name, ms, fail) {
return new Promise(function (resolve, reject) {
setTimeout(function () {
if (fail) {
reject(new Error("fail:" + name));
} else {
resolve("done:" + name);
}
}, ms);
});
}
console.log("demo job:", typeof fakeJob === "function");
Implementación del grupo de ejecución
runPool inicia algunos trabajadores; cada uno obtiene el índice de la siguiente tarea y espera a que termine. Los resultados conservan el orden de entrada.
// Run tasks with a fixed concurrency limit
async function runPool(tasks, limit) {
// tasks: array of functions () => Promise<any>
const results = new Array(tasks.length);
let next = 0;
// worker runs tasks until none left
async function worker() {
while (true) {
const i = next;
if (i >= tasks.length) return;
next = next + 1;
try {
const value = await tasks[i]();
results[i] = { ok: true, value: value };
} catch (e) {
results[i] = { ok: false, error: String(e) };
}
}
}
// start up to limit workers
const workers = [];
for (let k = 0; k < limit; k = k + 1) {
workers.push(worker());
}
await Promise.all(workers);
return results;
}
console.log("pool ready:", typeof runPool === "function");
Ejecutar el grupo
Limite a 2 los trabajos en curso. El arreglo conserva el orden: el índice i contiene el resultado de la tarea i.
// Prepare simple tasks
const jobs = [
function () { return fakeJob("A", 300, false); },
function () { return fakeJob("B", 200, false); },
function () { return fakeJob("C", 150, true ); },
function () { return fakeJob("D", 100, false); }
];
// Run with concurrency = 2
(async function () {
const out = await runPool(jobs, 2);
console.log("results:", out);
})();
Envoltorio opcional de reintento
Envuelva una tarea con un pequeño ayudante withRetry. Mantenga pequeños los números y sencilla la lógica.
// Optional: add retry to a task wrapper (beginner-friendly)
function withRetry(task, attempts) {
return async function () {
let lastErr = null;
for (let i = 0; i < attempts; i = i + 1) {
try {
return await task();
} catch (e) {
lastErr = e;
}
}
throw lastErr;
};
}
const jobsWithRetry = [
withRetry(function () { return fakeJob("R1", 80, true); }, 2),
withRetry(function () { return fakeJob("R2", 60, false); }, 2)
];
(async function () {
const out = await runPool(jobsWithRetry, 1);
console.log("retry results:", out);
})();
Orientación para principiantes
Consejos:
- Almacene las tareas como funciones () => Promise.
- Mantenga un índice siguiente compartido para la cola.
- Use try/catch en cada tarea y almacene los resultados.
- Elija un límite pequeño (2–4) para principiantes.
Cuestionario básico sobre el límite de concurrencia
Comprobación rápida: ¿por qué usar un grupo?
Repaso
Repaso: Un pequeño grupo de promesas ejecuta tareas con un límite fijo, mantiene el orden en un arreglo de resultados y usa un try/catch sencillo para cada tarea. Es un patrón excelente para principiantes.
Preguntas frecuentes
¿La lección «E3: pool/cola de Promises (concurrencia asíncrona)» es gratis?
Sí — el texto completo de «E3: pool/cola de Promises (concurrencia asíncrona)» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de JavaScript Academy, actualiza a CoddyKit PRO. El curso de JavaScript Academy incluye 3 lecciones en total.
¿Qué aprenderé en «E3: pool/cola de Promises (concurrencia asíncrona)»?
Ejecute muchas tareas asíncronas con un límite pequeño de concurrencia. Mantenga una cola, inicie varias a la vez y recopile los resultados. Practicas JavaScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar JavaScript Academy?
No se requiere experiencia previa. JavaScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.
¿Cuánto tiempo toma la lección «E3: pool/cola de Promises (concurrencia asíncrona)»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de JavaScript Academy?
Sí. Cada lección de JavaScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- E1: evaluador de expresiones (parte 1: + y - de izquierda a derecha)
- E2: analizador de logs (filtros y contadores sencillos)
- E3: pool/cola de Promises (concurrencia asíncrona)