mitmario.dev

Synthese: viele Dateien auf einmal

Node.js Sandbox 3 Min Lesezeit 4 BeispieleLektion 6 von 7

Neun Dateien einlesen, vierzig Adressen prüfen, zwölf Bilder umrechnen, hundert Datensätze in eine Schnittstelle schieben. Immer ist es eine Liste, für jeden Eintrag eine asynchrone Aufgabe und am Ende eine Auswertung. Bei Fremddaten ist oft ein Eintrag dabei, der nicht klappt.

Warum hier allSettled richtig ist

Bei einem Stapel Fremddaten ist Promise.all fast immer die falsche Wahl, weil es eine andere Frage beantwortet.

Promise.all sagt „ich brauche alle, sonst kann ich nicht weiterarbeiten“. Ein Fehlschlag ist dort ein Abbruch. Das passt, wenn du drei Teile einer Seite lädst und ohne einen davon nichts anzeigen kannst.

Promise.allSettled sagt „ich verarbeite, was da ist, und über den Rest berichte ich“. Ein Fehlschlag ist dort eine Nachricht. Das passt bei einem Eingangsordner, einem Import oder einer Auswertung, denn dort ist eine kaputte Datei noch lange kein Grund, die anderen acht gleich mit wegzuwerfen.

Was allSettled nicht abfängt

allSettled sieht nur, was in den Promises scheitert, die es bekommt.

Nur das Lesen abgefangen
import { readFile, writeFile } from "node:fs/promises";

await writeFile("montag.json", '{ "termine": 3 }');
await writeFile("dienstag.json", '{ "termine": ');

const ergebnisse = await Promise.allSettled(
  ["montag.json", "dienstag.json"].map((name) => readFile(name, "utf8")),
);

for (const eintrag of ergebnisse) {
  if (eintrag.status === "fulfilled") {
    console.log(`Termine: ${JSON.parse(eintrag.value).termine}`);
  }
}

console.log("Fertig.");

Die kaputte Datei lässt sich einwandfrei lesen, beide Promises sind erfüllt. Erst JSON.parse stößt auf das abgebrochene JSON. Das läuft hier aber in der Schleife nach allSettled, und dort fängt es niemand. Nach Termine: 3 bricht das Programm deshalb ab, mit SyntaxError: Unexpected end of JSON input, also „unerwartetes Ende der JSON-Eingabe“. Fertig. erscheint nie.

Das Ergebnis aufteilen

allSettled gibt dir eine gemischte Liste zurück, und meistens willst du sie getrennt haben. Der naheliegende Weg geht zweimal durch.

Zweimal filtern
const pruefen = async (nummer) => {
  if (nummer % 3 === 0) throw new Error(`${nummer} ist kaputt`);
  return `Datensatz ${nummer}`;
};

const ergebnisse = await Promise.allSettled([1, 2, 3, 4, 5, 6].map(pruefen));

const gute = ergebnisse.filter((e) => e.status === "fulfilled").map((e) => e.value);
const schlechte = ergebnisse.filter((e) => e.status === "rejected").map((e) => e.reason.message);

console.log(`${gute.length} gut, ${schlechte.length} kaputt`);
console.log(schlechte.join(" | "));

Das ist gut lesbar und für sechs Einträge völlig in Ordnung. Zwei Dinge stören trotzdem. Die Liste wird zweimal ganz durchlaufen und die beiden Teile danach noch einmal, obwohl ein Durchgang reichen würde. Schwerer wiegt das Zweite: Die beiden Zeilen können auseinanderlaufen. Ändert jemand die eine Bedingung und die andere nicht, zählt am Ende etwas doppelt oder gar nicht.

In einem Durchgang aufteilen
const pruefen = async (nummer) => {
  if (nummer % 3 === 0) throw new Error(`${nummer} ist kaputt`);
  return `Datensatz ${nummer}`;
};

const ergebnisse = await Promise.allSettled([1, 2, 3, 4, 5, 6].map(pruefen));

const gute = [];
const schlechte = [];

for (const eintrag of ergebnisse) {
  if (eintrag.status === "fulfilled") gute.push(eintrag.value);
  else schlechte.push(eintrag.reason.message);
}

console.log(`${gute.length} gut, ${schlechte.length} kaputt`);
console.log(schlechte.join(" | "));

Eine Schleife, eine Entscheidung, zwei Listen. Jeder Eintrag landet garantiert in genau einer davon, und das bleibt auch so, wenn später jemand etwas ergänzt.

Wenn wirklich viele Aufgaben anstehen

Alles gleichzeitig zu starten und einmal zu warten, geht gut, solange die Liste fest und klein ist.

Kommt ihre Länge von außen, wird es zum Problem. Zweitausend Dateien heißt zweitausend offene Dateihandles. Zweitausend Anfragen an eine fremde Schnittstelle können eine Sperre für deine IP-Adresse bedeuten. Manche Dienste sperren schon bei deutlich weniger.

Dagegen braucht es eine Obergrenze, und die kann man von Hand bauen.

Eine Obergrenze von Hand
const mitGrenze = async (eintraege, grenze, arbeit) => {
  const ergebnisse = [];
  let naechster = 0;

  const worker = async () => {
    while (naechster < eintraege.length) {
      const i = naechster;
      naechster += 1;
      ergebnisse[i] = await arbeit(eintraege[i]);
    }
  };

  await Promise.all(Array.from({ length: grenze }, worker));
  return ergebnisse;
};

let gleichzeitig = 0;
let hoechststand = 0;

const ergebnis = await mitGrenze([1, 2, 3, 4, 5, 6, 7, 8], 3, async (zahl) => {
  gleichzeitig += 1;
  hoechststand = Math.max(hoechststand, gleichzeitig);
  await new Promise((fertig) => setTimeout(fertig, 20));
  gleichzeitig -= 1;
  return zahl * 2;
});

console.log(`Ergebnis: ${ergebnis.join(",")}`);
console.log(`Höchstens gleichzeitig: ${hoechststand}`);

Der Trick sind die Worker. So heißen sie auch in der Fachwelt, und das ganze Muster heißt worker pool. Hier sind es gewöhnliche async-Funktionen, kein Thread wie in Lektion 6.5. Statt alle Aufgaben auf einmal zu starten, startest du drei Worker. Jeder holt sich die nächste freie Aufgabe, bis keine mehr da ist. Damit laufen nie mehr als drei gleichzeitig, und trotzdem ist immer Arbeit unterwegs.

Durch ergebnisse[i] landet jedes Ergebnis an seiner ursprünglichen Stelle, egal, wer wann fertig wird.

Fünfzehn Zeilen, kein Paket, keine Abhängigkeit. Es gibt fertige Pakete dafür, und die können mehr. Aber wenn du das Muster einmal selbst gebaut hast, weißt du, was sie tun, und kannst entscheiden, ob du sie brauchst.

In der Aufgabe liegt ein Eingangsordner mit neun Bestellungen, zwei davon kaputt.

Zum Mitnehmen

Ein Stapel gleicher Aufgaben läuft gleichzeitig, und allSettled sammelt Erfolge und Fehlschläge, solange alles, was scheitern kann, in seinen Promises steckt. Kommt die Länge der Liste von außen, gehört eine Obergrenze dazu.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.