js Promise-Methode zur gleichzeitigen Steuerung

Frage

Es ist erforderlich, eine Methode zum Steuern der Anzahl gleichzeitiger Promises wie folgt zu schreiben:

promiseConcurrencyLimit(Limit, Array, IteratorFn)

Limit ist die Anzahl der gleichzeitig ausgeführten Promises, Array ist das Parameter-Array und IteratorFn ist die asynchrone Operation, die in jedem Promise ausgeführt wird.

Hintergrund

Bei der Entwicklung müssen Sie nach der Verarbeitung mehrerer Promises eine Nachbearbeitungslogik ausführen. Normalerweise verwenden Sie dazu Promise.all:

Primise.alle([p1, p2, p3]).dann((res) => ...)

Es gibt jedoch ein Problem. Da Promise unmittelbar nach seiner Erstellung ausgeführt wird, d. h. mehrere Promise-Instanzen, die an Promise.all übergeben werden, werden bereits ausgeführt, wenn sie erstellt werden. Wenn die in diesen Instanzen ausgeführten asynchronen Vorgänge alle HTTP-Anfragen sind, werden sofort n HTTP-Anfragen ausgegeben, was offensichtlich unvernünftig ist. Eine vernünftigere Möglichkeit besteht darin, die Anzahl der in Promise.all ausgeführten asynchronen Vorgänge zu begrenzen und nur eine begrenzte Anzahl asynchroner Vorgänge gleichzeitig ausführen zu lassen.

Idee & Umsetzung

Wie im Hintergrund erwähnt, wird ein Promise unmittelbar nach seiner Erstellung ausgeführt, sodass der Kern der Steuerung der Parallelität in der Steuerung der Generierung von Promise-Instanzen liegt. Zu Beginn werden nur begrenzte Promise-Instanzen generiert und dann gewartet, bis sich der Status dieser Promises ändert. Sobald sich der Status einer der Promise-Instanzen ändert, wird sofort eine weitere Promise-Instanz erstellt ... Dieser Zyklus wird fortgesetzt, bis alle Promises erstellt und ausgeführt wurden.

Es gibt viele Bibliotheken auf npm, die diese Funktion implementieren. Ich persönlich denke, dass die Bibliothek tiny-async-pool besser ist, da sie zur Implementierung dieser Funktion direkt native Promise verwendet, während die meisten anderen Bibliotheken Promises erneut implementieren. Der Kerncode lautet wie folgt:

asynchrone Funktion asyncPool(PoolLimit, Array, IteratorFn) {
  const ret = []; // wird verwendet, um alle Promise-Instanzen zu speichern const executing = []; // wird verwendet, um das aktuell ausgeführte Promise zu speichern
  für (const Element des Arrays) {
    const p = Promise.resolve(iteratorFn(item)); // Um ​​zu verhindern, dass die Rückruffunktion etwas anderes als „Promise“ zurückgibt, umschließen Sie sie mit „Promise.resolve“ ret.push(p);
    wenn (PoolLimit <= Array.Länge) {
      // Wenn im then-Callback der Promise-Status erfüllt wird, löschen Sie ihn aus der Liste der ausgeführten Promises. execution const e = p.then(() => executing.splice(executing.indexOf(e), 1));
      Ausführen von Push(e);
      wenn (Ausführungslänge >= PoolLimit) {
        // Sobald die Anzahl der ausgeführten Promise-Listen dem Limit entspricht, verwenden Sie Promise.race, um auf eine Änderung des Promise-Status zu warten.
        // Nachdem sich der Status geändert hat, wird der Rückruf von then ausgeführt und das Versprechen wird aus der Ausführung gelöscht.
        //Gehen Sie dann in die nächste For-Schleife und generieren Sie ein neues Promise als Ergänzung zu await Promise.race(executing);
      }
    }
  }
  gibt Promise.all(ret) zurück;
}

Der Testcode lautet wie folgt:

const timeout = (i) => {
  Konsole.log('starten', i);
  returniere neues Promise((auflösen) => setTimeout(() => {
    Entschlossenheit (i);
    konsole.log('Ende', i);
  }, ich));
};

(asynchron () => {
    const res = warte auf asyncPool(2, [1000, 5000, 3000, 2000], Zeitüberschreitung);
    konsole.log(res);
  })();

Die Kernidee des Codes ist:

• Initialisieren Sie zunächst Limit-Promise-Instanzen und legen Sie diese in das ausführende Array
• Verwenden Sie Promise.race, um auf die Ausführungsergebnisse dieser Limit-Promise-Instanzen zu warten
• Sobald sich der Status eines Versprechens ändert, wird es aus der Ausführung entfernt und anschließend die Schleife ausgeführt, um ein neues Versprechen zu generieren und es in die Ausführung zu setzen.
• Wiederholen Sie die Schritte 2 und 3, bis alle Versprechen ausgeführt sind.
• Verwenden Sie abschließend Promise.all, um die Ausführungsergebnisse aller Promise-Instanzen zurückzugeben

Dies ist das Ende dieses Artikels über die Methode zur Steuerung der Anzahl gleichzeitiger Aufrufe in js Promise. Weitere relevante Inhalte zur gleichzeitigen Steuerung von js Promise finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!