Beispielcode zur Implementierung der gleichzeitigen Anforderungssteuerung in JavaScript/TypeScript

let startTime = Date.now();
const timeout = (timeout: Zahl, ret: Zahl) => {
 return (idx?: beliebig) =>
 neues Versprechen((lösen) => {
  setzeTimeout(() => {
  const vergleichen = Date.now() - Startzeit;
  console.log(`Bei ${Math.floor(compare / 100)}00 returnieren`, ret);
  auflösen (idx);
  }, Zeitüberschreitung);
 });
};

const timeout1 = timeout(1000, 1);
const timeout2 = timeout(300, 2);
const timeout3 = timeout(400, 3);
const timeout4 = timeout(500, 4);
const timeout5 = timeout(200, 5);

const run = async () => {
 Startzeit = Datum.jetzt();
 warte auf Promise.all([
 Zeitüberschreitung1(),
 timeout2(),
 timeout3(),
 timeout4(),
 timeout5(),
 ]);
};

laufen();

Bei 200 Rückkehr 5
Bei 300 Rückkehr 2
Bei 400 Rückkehr 3
Bei 500 Rückkehr 4
Bei 1000 Rückkehr 1

Klasse Gleichzeitig {
 private maxConcurrent: Zahl = 2;

 Konstruktor(Anzahl: Zahl = 2) {
 this.maxConcurrent = Anzahl;
 }
}

Klasse Gleichzeitig {
 private maxConcurrent: Zahl = 2;

 Konstruktor(Anzahl: Zahl = 2) {
 this.maxConcurrent = Anzahl;
 }
 öffentliche asynchrone useRace(fns: Funktion[]) {
 const läuft: beliebig[] = [];
 // Promises entsprechend der Anzahl der Parallelitäten hinzufügen // Promises rufen einen Index zurück, sodass wir wissen, welches Promise aufgelöst wurde (let i = 0; i < this.maxConcurrent; i++) {
  wenn (fns.Länge) {
  const fn = fns.shift()!;
  ausführen.push(fn(i));
  }
 }
 const handle = async () => {
  wenn (fns.Länge) {
  const idx = warte auf Promise.race<Nummer>(läuft);
  const nextFn = fns.shift()!;
  // Entfernen Sie das abgeschlossene Promise und fügen Sie das neue in runing.splice(idx, 1, nextFn(idx)); ein.
  handhaben();
  } anders {
  // Wenn das Array gelöscht wurde, bedeutet dies, dass kein auszuführendes Promise vorhanden ist. Sie können es in Promise.all ändern.
  warte auf Promise.all(running);
  }
 };
 handhaben();
 }
}

const run = async () => {
 const parallel = neues paralleles();
 Startzeit = Datum.jetzt();
 warte auf concurrent.useRace([timeout1, timeout2, timeout3, timeout4, timeout5]);
};

Bei 300 Rückkehr 2
Bei 700 Rückkehr 3
Bei 1000 Rückkehr 1
Um 1200 zurück 5
Um 1200 Rückkehr 4

Klasse Gleichzeitig {
 private maxConcurrent: Zahl = 2;
 private Liste: Funktion[] = [];
 privater aktuellerAnzahl: Zahl = 0;

 Konstruktor(Anzahl: Zahl = 2) {
 this.maxConcurrent = Anzahl;
 }
 öffentliches asynchrones Addieren (fn: Funktion) {
 dies.aktuellerAnzahl += 1;
 // Wenn die maximale Anzahl gleichzeitiger Verbindungen das Maximum überschritten hat, if (this.currentCount > this.maxConcurrent) {
  // wait ist ein Promise, welches erfüllt wird, sobald resolve aufgerufen wird const wait = new Promise((resolve) => {
  diese.Liste.push(auflösen);
  });
  // Wenn „resolve“ nicht aufgerufen wird, wird „await wait“ hier blockiert.
 }
 //Funktion ausführen await fn();
 dies.aktuellerAnzahl -= 1;
 wenn (diese.Liste.Länge) {
  // Nehmen Sie „resolve“ heraus und rufen Sie es auf, damit das Warten abgeschlossen ist und Sie es unten ausführen können. const resolveHandler = this.list.shift()!;
  lösenHandler();
 }
 }
}

const run = async () => {
 const parallel = neues paralleles();
 Startzeit = Datum.jetzt();
 gleichzeitiges Hinzufügen (Timeout1);
 gleichzeitiges Hinzufügen (Timeout2);
 gleichzeitiges Hinzufügen (Timeout3);
 gleichzeitiges Hinzufügen (Timeout4);
 gleichzeitiges Hinzufügen (Timeout5);
};

laufen();

Bei 300 Rückkehr 2
Bei 700 Rückkehr 3
Bei 1000 Rückkehr 1
Um 1200 zurück 5
Um 1200 Rückkehr 4