Verarbeitet Node.js natives Promise.all parallel oder sequentiell?

Question 1

Ich möchte diesen Punkt klarstellen, da die Dokumentation ist sich darüber nicht allzu klar;

Q1: Ist Promise.all(iterable) alle Promises sequentiell oder parallel abarbeiten? Oder, genauer gesagt, ist es das Äquivalent zu laufenden verketteten Versprechen wie

p1.then(p2).then(p3).then(p4).then(p5)....

oder ist es eine andere Art von Algorithmus, bei dem alle p1, p2, p3, p4, p5etc. werden gleichzeitig (parallel) aufgerufen und Ergebnisse werden zurückgegeben, sobald alle aufgelöst (oder einer verworfen)?

Q2: Wenn Promise.all Läuft parallel, gibt es eine bequeme Möglichkeit, eine Iteration sequenziell auszuführen?

Notiz: Ich möchte nicht Q oder Bluebird verwenden, sondern alle nativen ES6-Spezifikationen.

Question 2

Ist Promise.all(iterable) alle Versprechen einhalten?

Nein, Versprechen können nicht „eingelöst“ werden. Sie beginnen ihre Aufgabe, wenn sie sind erstellt – sie stellen nur die Ergebnisse dar – und Sie führen alles parallel aus, noch bevor sie an sie übergeben werden Promise.all.

Promise.all tut nur erwarten mehrere Versprechungen. Es spielt keine Rolle, in welcher Reihenfolge sie aufgelöst werden oder ob die Berechnungen parallel ausgeführt werden.

Gibt es eine bequeme Möglichkeit, eine Iteration sequenziell auszuführen?

Wenn Sie Ihre Versprechen bereits haben, können Sie nicht viel tun, aber Promise.all([p1, p2, p3, …]) (die keinen Begriff der Sequenz hat). Aber wenn Sie eine iterierbare asynchrone Funktion haben, können Sie sie tatsächlich nacheinander ausführen. Grundsätzlich müssen Sie aus

[fn1, fn2, fn3, …]

zu

fn1().then(fn2).then(fn3).then(…)

und die Lösung dafür ist die Verwendung Array::reduce:

iterable.reduce((p, fn) => p.then(fn), Promise.resolve())

Question 3

Parallel zu

await Promise.all(items.map(async (item) => { 
  await fetchItem(item) 
}))

Vorteile: Schneller. Alle Iterationen werden gestartet, auch wenn später eine fehlschlägt. Allerdings wird es “schnell scheitern”. Verwenden Promise.allSettledum alle Iterationen parallel abzuschließen, auch wenn einige fehlschlagen.

Der Reihe nach

for (const item of items) {
  await fetchItem(item)
}

Vorteile: Variablen in der Schleife können von jeder Iteration gemeinsam genutzt werden. Verhält sich wie normaler imperativer synchroner Code.

Question 4

NodeJS führt Promises nicht parallel aus, es führt sie gleichzeitig aus, da es sich um eine Single-Threaded-Event-Loop-Architektur handelt. Es besteht die Möglichkeit, Dinge parallel auszuführen, indem ein neuer untergeordneter Prozess erstellt wird, um die Vorteile der Mehrkern-CPU zu nutzen.

Parallel vs. gleichzeitig

In der Tat, was Promise.all die Promises-Funktion in der entsprechenden Warteschlange stapeln (siehe Ereignisschleifenarchitektur), sie gleichzeitig ausführen (P1, P2 aufrufen, …), dann auf jedes Ergebnis warten und dann Promise.all mit allen Promises-Ergebnissen auflösen. Promise.all schlägt beim ersten fehlgeschlagenen Versprechen fehl, es sei denn, Sie müssen die Ablehnung selbst verwalten.

Es gibt einen großen Unterschied zwischen parallel und gleichzeitig, der erste führt eine andere Berechnung in einem separaten Prozess genau zur gleichen Zeit aus und sie werden in ihrem Rhythmus fortschreiten, während der andere die verschiedenen Berechnungen nacheinander ohne Wartezeit ausführt die vorherige Berechnung zur gleichen Zeit zu beenden und fortzusetzen, ohne voneinander abhängig zu sein.

Um Ihre Frage abschließend zu beantworten, Promise.all werden weder parallel noch sequentiell, sondern gleichzeitig ausgeführt.

Question 5

Bergis Antwort hat mich auf die richtige Spur gebracht Array.reduce.

Um jedoch tatsächlich die Funktionen zu erhalten, die meine Versprechen zurückgeben, um sie nacheinander auszuführen, musste ich noch mehr Verschachtelungen hinzufügen.

Mein eigentlicher Anwendungsfall ist eine Reihe von Dateien, die ich aufgrund nachgelagerter Einschränkungen nacheinander übertragen muss …

Hier ist, was ich am Ende hatte:

getAllFiles().then( (files) => {
    return files.reduce((p, theFile) => {
        return p.then(() => {
            return transferFile(theFile); //function returns a promise
        });
    }, Promise.resolve()).then(()=>{
        console.log("All files transferred");
    });
}).catch((error)=>{
    console.log(error);
});

Wie vorherige Antworten vermuten lassen, verwenden Sie:

getAllFiles().then( (files) => {
    return files.reduce((p, theFile) => {
        return p.then(transferFile(theFile));
    }, Promise.resolve()).then(()=>{
        console.log("All files transferred");
    });
}).catch((error)=>{
    console.log(error);
});

Ich habe nicht gewartet, bis die Übertragung abgeschlossen ist, bevor ich eine weitere gestartet habe, und auch der Text “Alle Dateien übertragen” wurde angezeigt, bevor die erste Dateiübertragung gestartet wurde.

Ich bin mir nicht sicher, was ich falsch gemacht habe, wollte aber mitteilen, was für mich funktioniert hat.

Edit: Seit ich diesen Beitrag geschrieben habe, verstehe ich jetzt, warum die erste Version nicht funktioniert hat. then() erwartet ein Funktion ein Versprechen zurückgeben. Sie sollten also den Funktionsnamen ohne Klammern übergeben! Jetzt will meine Funktion ein Argument, also muss ich mich in eine anonyme Funktion einschließen, die kein Argument hat!

Question 6

Sie können eine Iterable auch sequenziell mit einer asynchronen Funktion unter Verwendung einer rekursiven Funktion verarbeiten. Zum Beispiel ein Array gegeben a mit asynchroner Funktion verarbeiten someAsyncFunction():

var a = [1, 2, 3, 4, 5, 6]

function someAsyncFunction(n) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("someAsyncFunction: ", n)
      resolve(n)
    }, Math.random() * 1500)
  })
}

//You can run each array sequentially with: 

function sequential(arr, index = 0) {
  if (index >= arr.length) return Promise.resolve()
  return someAsyncFunction(arr[index])
    .then(r => {
      console.log("got value: ", r)
      return sequential(arr, index + 1)
    })
}

sequential(a).then(() => console.log("done"))

Question 7

Nur um auf die Antwort von @Bergi einzugehen (die sehr prägnant, aber schwer zu verstehen ist;)

Dieser Code führt jedes Element im Array aus und fügt die nächste ‘then-Kette’ am Ende hinzu:

function eachorder(prev,order) {
        return prev.then(function() {
          return get_order(order)
            .then(check_order)
            .then(update_order);
        });
    }
orderArray.reduce(eachorder,Promise.resolve());

Question 8

Verwenden asynchron warten Eine Reihe von Promises kann einfach nacheinander ausgeführt werden:

let a = [promise1, promise2, promise3];

async function func() {
  for(let i=0; i<a.length; i++){
    await a[i]();
  }  
}

func();

Hinweis: Wenn in der obigen Implementierung ein Promise abgelehnt wird, wird der Rest nicht ausgeführt. Wenn Sie möchten, dass alle Ihre Promises ausgeführt werden, wickeln Sie Ihr Promise ein await a[i](); Innerhalb try catch