E3 – Promise-Pool/-Warteschlange (asynchrone Nebenläufigkeit)
Viele asynchrone Tasks mit einem kleinen Nebenläufigkeitslimit ausführen. Eine Warteschlange verwalten, einige Tasks gleichzeitig starten und Ergebnisse sammeln
E3 – Promise-Pool/-Warteschlange (asynchrone Nebenläufigkeit) ist eine kostenlose JavaScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des JavaScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der JavaScript Academy-Kurs umfasst insgesamt 3 Lektionen.
Worum es geht und warum
Ziel: Viele asynchrone Jobs ausführen, ohne das System zu überlasten.
- Parallelität begrenzen (z. B. 2 gleichzeitig)
- Einen einfachen Warteschlangenindex verwenden
- Ergebnisse in einem Array speichern
- Anfängerfreundlicher Code mit kleinen Helfern
Helfer für asynchrone Jobs
Ein kleiner Helfer gibt ein Promise zurück, das nach einer Verzögerung aufgelöst wird; zum Testen kann er optional fehlschlagen.
// 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");
Implementierung des Pools
runPool startet einige Worker; jeder holt den Index der nächsten Aufgabe und wartet auf sie. Die Ergebnisse behalten die Reihenfolge der Eingaben bei.
// 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");
Den Pool ausführen
Beschränken Sie die Anzahl gleichzeitig laufender Jobs auf 2. Das Array behält die Reihenfolge bei: Der Index i enthält das Ergebnis der Aufgabe 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);
})();
Optionaler Retry-Wrapper
Umschließen Sie eine Aufgabe mit einem kleinen withRetry-Helfer. Halten Sie Zahlen und Logik einfach.
// 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);
})();
Hinweise für Einsteiger
Tipps:
- Speichern Sie Aufgaben als () => Promise-Funktionen.
- Verwenden Sie für die Warteschlange einen gemeinsamen nächsten Index.
- Verwenden Sie für jede Aufgabe try/catch und speichern Sie die Ergebnisse.
- Wählen Sie für Einsteiger ein kleines Limit (2–4).
Quiz zu den Grundlagen der Nebenläufigkeitsbegrenzung
Kurze Überprüfung: Warum einen Pool?
Zusammenfassung
Zusammenfassung: Ein kleiner Promise-Pool führt Aufgaben mit einem festen Limit aus, behält ihre Reihenfolge in einem Ergebnis-Array bei und verwendet für jede Aufgabe ein einfaches try/catch. Ein hervorragendes Muster für Einsteiger.
Häufig gestellte Fragen
Ist die Lektion „E3 – Promise-Pool/-Warteschlange (asynchrone Nebenläufigkeit)“ kostenlos?
Ja — der vollständige Text von „E3 – Promise-Pool/-Warteschlange (asynchrone Nebenläufigkeit)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des JavaScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der JavaScript Academy-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „E3 – Promise-Pool/-Warteschlange (asynchrone Nebenläufigkeit)“?
Viele asynchrone Tasks mit einem kleinen Nebenläufigkeitslimit ausführen. Eine Warteschlange verwalten, einige Tasks gleichzeitig starten und Ergebnisse sammeln Du übst JavaScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um JavaScript Academy zu starten?
Keine Vorkenntnisse erforderlich. JavaScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 3.
Wie lange dauert die Lektion „E3 – Promise-Pool/-Warteschlange (asynchrone Nebenläufigkeit)“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser JavaScript Academy-Lektion Code schreiben und ausführen?
Ja. Jede JavaScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- E1 – Ausdrucksauswerter (Teil 1: + und - von links nach rechts)
- E3 – Log-Analysator (einfache Filter und Zähler)
- E3 – Promise-Pool/-Warteschlange (asynchrone Nebenläufigkeit)