E3 — Pool/coda di Promise (concorrenza asincrona)
Esegui molte attività asincrone con un piccolo limite di concorrenza. Mantieni una coda, avviane alcune alla volta e raccogli i risultati.
E3 — Pool/coda di Promise (concorrenza asincrona) è una lezione JavaScript Academy gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento JavaScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso JavaScript Academy include 3 lezioni in totale.
Cosa e perché
Obiettivo: eseguire molti job asincroni senza sovraccaricare il sistema.
- Limitare la concorrenza (ad es. 2 alla volta)
- Mantenere un semplice indice della coda
- Memorizzare i risultati in un array
- Utilizzare codice adatto ai principianti e piccoli helper
Helper per i job asincroni
Un piccolo helper restituisce una Promise che si risolve dopo un ritardo; può fallire facoltativamente per i test.
// 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");
Implementazione del pool
runPool avvia alcuni worker; ciascuno preleva l'indice dell'attività successiva e usa await su di essa. I risultati mantengono l'ordine di input.
// 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");
Eseguire il pool
Limiti a 2 i job in esecuzione. L'array mantiene l'ordine: l'indice i contiene il risultato dell'attività 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);
})();
Wrapper opzionale per i retry
Racchiuda un'attività in un piccolo helper withRetry. Mantenga piccoli i numeri e semplice la logica.
// 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);
})();
Guida per principianti
Suggerimenti:
- Memorizzi le attività come funzioni () => Promise.
- Mantenga un indice successivo condiviso per la coda.
- Usi try/catch per ogni attività e memorizzi i risultati.
- Scelga un limite ridotto (2–4) per chi è agli inizi.
Quiz di base sui limiti di concorrenza
Verifica rapida: perché usare un pool?
Riepilogo
Riepilogo: un piccolo pool di promise esegue le attività con un limite fisso, ne mantiene l'ordine in un array di risultati e usa un semplice try/catch per ogni attività. Un ottimo modello per chi è agli inizi.
Domande Frequenti
La lezione «E3 — Pool/coda di Promise (concorrenza asincrona)» è gratuita?
Sì — il testo completo di «E3 — Pool/coda di Promise (concorrenza asincrona)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso JavaScript Academy, passa a CoddyKit PRO. Il corso JavaScript Academy include 3 lezioni in totale.
Cosa imparerò in «E3 — Pool/coda di Promise (concorrenza asincrona)»?
Esegui molte attività asincrone con un piccolo limite di concorrenza. Mantieni una coda, avviane alcune alla volta e raccogli i risultati. Eserciti JavaScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare JavaScript Academy?
Non è richiesta alcuna esperienza precedente. JavaScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.
Quanto tempo richiede la lezione «E3 — Pool/coda di Promise (concorrenza asincrona)»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione JavaScript Academy?
Sì. Ogni lezione JavaScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- E1 — Valutatore di espressioni (parte 1: + e - da sinistra a destra)
- E2 — Analizzatore di log (filtri e contatori semplici)
- E3 — Pool/coda di Promise (concorrenza asincrona)