E3 — Réservoir ou file de promesses (concurrence asynchrone)
Exécutez de nombreuses tâches asynchrones avec une petite limite de concurrence. Gérez une file, démarrez quelques tâches à la fois et rassemblez les résultats
E3 — Réservoir ou file de promesses (concurrence asynchrone) est une leçon JavaScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage JavaScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours JavaScript Academy comprend 3 leçons au total.
Quoi et pourquoi
Objectif : exécuter de nombreuses tâches async sans surcharger le système.
- Limiter la concurrence (par ex. 2 à la fois)
- Garder un simple index de file d’attente
- Stocker les résultats dans un tableau
- Utiliser un code adapté aux débutants et de petits assistants
Assistant de tâche asynchrone
Un petit assistant renvoie une Promise qui se résout après un délai ; il peut éventuellement échouer pour les tests.
// 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");
Implémentation du pool
runPool démarre quelques workers ; chacun récupère l’index de tâche suivant et attend son résultat avec await. Les résultats conservent l’ordre des entrées.
// 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");
Exécuter le pool
Limitez à 2 tâches en cours. Le tableau conserve l’ordre : l’index i contient le résultat de la tâche 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);
})();
Enveloppe de nouvelle tentative facultative
Entourez une tâche d’un petit assistant withRetry. Gardez les nombres petits et la logique simple.
// 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);
})();
Conseils pour débutants
Conseils :
- Stockez les tâches sous forme de fonctions qui renvoient une promesse.
- Conservez un index next partagé pour la file.
- Utilisez une gestion des erreurs pour chaque tâche et stockez les résultats.
- Choisissez une petite limite (2–4) pour les débutants.
Quiz sur les notions de base de la limite de concurrence
Vérification rapide : pourquoi utiliser un groupe de promesses ?
Récapitulatif
Récapitulatif : un petit groupe de promesses exécute les tâches avec une limite fixe, conserve leur ordre dans un tableau de résultats et utilise une simple gestion des erreurs pour chaque tâche. C’est un modèle idéal pour débuter.
Questions Fréquemment Posées
La leçon « E3 — Réservoir ou file de promesses (concurrence asynchrone) » est-elle gratuite ?
Oui — le texte complet de « E3 — Réservoir ou file de promesses (concurrence asynchrone) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours JavaScript Academy, passe à CoddyKit PRO. Le cours JavaScript Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « E3 — Réservoir ou file de promesses (concurrence asynchrone) » ?
Exécutez de nombreuses tâches asynchrones avec une petite limite de concurrence. Gérez une file, démarrez quelques tâches à la fois et rassemblez les résultats Tu pratiques JavaScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer JavaScript Academy ?
Aucune expérience préalable n'est requise. JavaScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 3.
Combien de temps prend la leçon « E3 — Réservoir ou file de promesses (concurrence asynchrone) » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon JavaScript Academy ?
Oui. Chaque leçon JavaScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- E1 — Évaluateur d’expressions (1re partie : + et - de gauche à droite)
- E2 — Analyseur de journaux (filtres et compteurs simples)
- E3 — Réservoir ou file de promesses (concurrence asynchrone)