Rufen Sie parallel asynchrone / warten-Funktionen auf

Soweit ich weiß, funktioniert das Einfügen mehrerer awaitCodes in ES7 / ES2016 ähnlich wie das Verketten .then()mit Versprechungen, was bedeutet, dass sie nacheinander und nicht parallel ausgeführt werden. So haben wir zum Beispiel diesen Code:

await someCall();
await anotherCall();

Verstehe ich es richtig, dass anotherCall()erst aufgerufen wird, wenn someCall()es abgeschlossen ist? Was ist die eleganteste Art, sie parallel zu nennen?

Ich möchte es in Node verwenden, also gibt es vielleicht eine Lösung mit asynchroner Bibliothek?

BEARBEITEN: Ich bin mit der in dieser Frage bereitgestellten Lösung nicht zufrieden: Verlangsamung aufgrund des nicht parallelen Wartens auf Versprechen in asynchronen Generatoren , da Generatoren verwendet werden und ich nach einem allgemeineren Anwendungsfall frage.

Sie können warten auf Promise.all():

await Promise.all([someCall(), anotherCall()]);

So speichern Sie die Ergebnisse:

let [someResult, anotherResult] = await Promise.all([someCall(), anotherCall()]);

Beachten Sie, dass Promise.alldies schnell fehlschlägt. Dies bedeutet, dass das gesamte Objekt abgelehnt wird, sobald eines der ihm gegebenen Versprechen abgelehnt wird.

const happy = (v, ms) => new Promise((resolve) => setTimeout(() => resolve(v), ms))
const sad = (v, ms) => new Promise((_, reject) => setTimeout(() => reject(v), ms))

Promise.all([happy('happy', 100), sad('sad', 50)])
  .then(console.log).catch(console.log) // 'sad'

Wenn Sie stattdessen darauf warten möchten, dass alle Versprechen erfüllt oder abgelehnt werden, können Sie sie verwenden Promise.allSettled. Beachten Sie, dass Internet Explorer diese Methode nicht nativ unterstützt.

const happy = (v, ms) => new Promise((resolve) => setTimeout(() => resolve(v), ms))
const sad = (v, ms) => new Promise((_, reject) => setTimeout(() => reject(v), ms))

Promise.allSettled([happy('happy', 100), sad('sad', 50)])
  .then(console.log) // [{ "status":"fulfilled", "value":"happy" }, { "status":"rejected", "reason":"sad" }]

TL; DR

Verwenden Sie Promise.allfür die parallelen Funktionsaufrufe das Antwortverhalten nicht korrekt, wenn der Fehler auftritt.

Führen Sie zunächst alle asynchronen Aufrufe gleichzeitig aus und erhalten Sie alle PromiseObjekte. Zweitens awaitfür die PromiseObjekte verwenden. Auf diese Weise werden Promisedie anderen asynchronen Aufrufe fortgesetzt , während Sie darauf warten, dass der erste die anderen asynchronen Aufrufe auflöst. Insgesamt warten Sie nur so lange wie der langsamste asynchrone Anruf. Zum Beispiel:

// Begin first call and store promise without waiting
const someResult = someCall();

// Begin second call and store promise without waiting
const anotherResult = anotherCall();

// Now we await for both results, whose async processes have already been started
const finalResult = [await someResult, await anotherResult];

// At this point all calls have been resolved
// Now when accessing someResult| anotherResult,
// you will have a value instead of a promise

JSbin-Beispiel: http://jsbin.com/xerifanima/edit?js,console

Vorsichtsmaßnahme: Es spielt keine Rolle, ob sich die awaitAnrufe auf derselben Leitung oder auf verschiedenen Leitungen befinden, solange der erste awaitAnruf nach allen asynchronen Anrufen erfolgt. Siehe JohnnyHKs Kommentar.

Update: Diese Antwort hat ein anderes Timing bei der Fehlerbehandlung als die Antwort von @ bergi . Sie wirft den Fehler NICHT aus, wenn der Fehler auftritt, sondern nachdem alle Versprechen ausgeführt wurden. Ich vergleiche das Ergebnis mit @ jonnys Tipp: [result1, result2] = Promise.all([async1(), async2()])Überprüfen Sie das folgende Code-Snippet

const correctAsync500ms = () => {
  return new Promise(resolve => {
    setTimeout(resolve, 500, 'correct500msResult');
  });
};

const correctAsync100ms = () => {
  return new Promise(resolve => {
    setTimeout(resolve, 100, 'correct100msResult');
  });
};

const rejectAsync100ms = () => {
  return new Promise((resolve, reject) => {
    setTimeout(reject, 100, 'reject100msError');
  });
};

const asyncInArray = async (fun1, fun2) => {
  const label = 'test async functions in array';
  try {
    console.time(label);
    const p1 = fun1();
    const p2 = fun2();
    const result = [await p1, await p2];
    console.timeEnd(label);
  } catch (e) {
    console.error('error is', e);
    console.timeEnd(label);
  }
};

const asyncInPromiseAll = async (fun1, fun2) => {
  const label = 'test async functions with Promise.all';
  try {
    console.time(label);
    let [value1, value2] = await Promise.all([fun1(), fun2()]);
    console.timeEnd(label);
  } catch (e) {
    console.error('error is', e);
    console.timeEnd(label);
  }
};

(async () => {
  console.group('async functions without error');
  console.log('async functions without error: start')
  await asyncInArray(correctAsync500ms, correctAsync100ms);
  await asyncInPromiseAll(correctAsync500ms, correctAsync100ms);
  console.groupEnd();

  console.group('async functions with error');
  console.log('async functions with error: start')
  await asyncInArray(correctAsync500ms, rejectAsync100ms);
  await asyncInPromiseAll(correctAsync500ms, rejectAsync100ms);
  console.groupEnd();
})();

Aktualisieren:

Die ursprüngliche Antwort macht es schwierig (und in einigen Fällen unmöglich), Versprechungen abzulehnen. Die richtige Lösung ist zu verwenden Promise.all:

const [someResult, anotherResult] = await Promise.all([someCall(), anotherCall()]);

Ursprüngliche Antwort:

Stellen Sie einfach sicher, dass Sie beide Funktionen aufrufen, bevor Sie auf eine der beiden warten:

// Call both functions
const somePromise = someCall();
const anotherPromise = anotherCall();

// Await both promises    
const someResult = await somePromise;
const anotherResult = await anotherPromise;

Es gibt einen anderen Weg ohne Promise.all (), dies parallel zu tun:

Erstens haben wir zwei Funktionen zum Drucken von Zahlen:

function printNumber1() {
   return new Promise((resolve,reject) => {
      setTimeout(() => {
      console.log("Number1 is done");
      resolve(10);
      },1000);
   });
}

function printNumber2() {
   return new Promise((resolve,reject) => {
      setTimeout(() => {
      console.log("Number2 is done");
      resolve(20);
      },500);
   });
}

Dies ist sequentiell:

async function oneByOne() {
   const number1 = await printNumber1();
   const number2 = await printNumber2();
} 
//Output: Number1 is done, Number2 is done

Das ist parallel:

async function inParallel() {
   const promise1 = printNumber1();
   const promise2 = printNumber2();
   const number1 = await promise1;
   const number2 = await promise2;
}
//Output: Number2 is done, Number1 is done

Dies kann mit Promise.allSettled () erreicht werden , das Promise.all()dem ausfallsicheren Verhalten ähnelt, jedoch ohne dieses ausfällt.

async function failure() {
    throw "Failure!";
}

async function success() {
    return "Success!";
}

const [failureResult, successResult] = await Promise.allSettled([failure(), success()]);

console.log(failureResult); // {status: "rejected", reason: "Failure!"}
console.log(successResult); // {status: "fulfilled", value: "Success!"}

Hinweis : Dies ist eine hochmoderne Funktion mit eingeschränkter Browserunterstützung. Ich empfehle daher dringend , für diese Funktion eine Polyfüllung hinzuzufügen.

Ich habe eine Übersicht erstellt , in der verschiedene Methoden zur Lösung von Versprechungen mit Ergebnissen getestet wurden. Es kann hilfreich sein, die Optionen anzuzeigen, die funktionieren.

    // A generic test function that can be configured 
    // with an arbitrary delay and to either resolve or reject
    const test = (delay, resolveSuccessfully) => new Promise((resolve, reject) => setTimeout(() => {
        console.log(`Done ${ delay }`);
        resolveSuccessfully ? resolve(`Resolved ${ delay }`) : reject(`Reject ${ delay }`)
    }, delay));

    // Our async handler function
    const handler = async () => {
        // Promise 1 runs first, but resolves last
        const p1 = test(10000, true);
        // Promise 2 run second, and also resolves
        const p2 = test(5000, true);
        // Promise 3 runs last, but completes first (with a rejection) 
        // Note the catch to trap the error immediately
        const p3 = test(1000, false).catch(e => console.log(e));
        // Await all in parallel
        const r = await Promise.all([p1, p2, p3]);
        // Display the results
        console.log(r);
    };

    // Run the handler
    handler();
    /*
    Done 1000
    Reject 1000
    Done 5000
    Done 10000
    */

Während das Setzen von p1, p2 und p3 sie nicht streng parallel ausführt, halten sie keine Ausführung auf und Sie können Kontextfehler mit einem Catch abfangen.

warte auf Promise.all ([someCall (), anotherCall ()]); Wie bereits erwähnt, fungiert es als Thread-Zaun (im parallelen Code als CUDA sehr häufig), sodass alle darin enthaltenen Versprechen ausgeführt werden können, ohne sich gegenseitig zu blockieren. Es wird jedoch verhindert, dass die Ausführung fortgesetzt wird, bis ALLE gelöst sind.

Ein weiterer Ansatz, der es wert ist, geteilt zu werden, ist die asynchrone Node.js-Methode, mit der Sie auch die Menge an Parallelität steuern können, die normalerweise wünschenswert ist, wenn die Aufgabe direkt mit der Verwendung begrenzter Ressourcen als API-Aufruf, E / A-Operationen, verknüpft ist. usw.

// create a queue object with concurrency 2
var q = async.queue(function(task, callback) {
  console.log('Hello ' + task.name);
  callback();
}, 2);

// assign a callback
q.drain = function() {
  console.log('All items have been processed');
};

// add some items to the queue
q.push({name: 'foo'}, function(err) {
  console.log('Finished processing foo');
});

q.push({name: 'bar'}, function (err) {
  console.log('Finished processing bar');
});

// add some items to the queue (batch-wise)
q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {
  console.log('Finished processing item');
});

// add some items to the front of the queue
q.unshift({name: 'bar'}, function (err) {
  console.log('Finished processing bar');
});

Credits für den Autor des Medium-Artikels ( lesen Sie mehr )

In meinem Fall habe ich mehrere Aufgaben, die ich parallel ausführen möchte, aber ich muss mit dem Ergebnis dieser Aufgaben etwas anderes tun.

function wait(ms, data) {
    console.log('Starting task:', data, ms);
    return new Promise(resolve => setTimeout(resolve, ms, data));
}

var tasks = [
    async () => {
        var result = await wait(1000, 'moose');
        // do something with result
        console.log(result);
    },
    async () => {
        var result = await wait(500, 'taco');
        // do something with result
        console.log(result);
    },
    async () => {
        var result = await wait(5000, 'burp');
        // do something with result
        console.log(result);
    }
]

await Promise.all(tasks.map(p => p()));
console.log('done');

Und die Ausgabe:

Starting task: moose 1000
Starting task: taco 500
Starting task: burp 5000
taco
moose
burp
done

Ich stimme für:

await Promise.all([someCall(), anotherCall()]);

Beachten Sie den Moment, in dem Sie Funktionen aufrufen. Dies kann zu unerwarteten Ergebnissen führen:

// Supposing anotherCall() will trigger a request to create a new User

if (callFirst) {
  await someCall();
} else {
  await Promise.all([someCall(), anotherCall()]); // --> create new User here
}

Das Folgen löst jedoch immer die Anforderung aus, einen neuen Benutzer zu erstellen

// Supposing anotherCall() will trigger a request to create a new User

const someResult = someCall();
const anotherResult = anotherCall(); // ->> This always creates new User

if (callFirst) {
  await someCall();
} else {
  const finalResult = [await someResult, await anotherResult]
}

Ich erstelle eine Hilfsfunktion waitAll, vielleicht kann sie süßer werden. Es funktioniert momentan nur in NodeJS , nicht in Browser Chrome.

    //const parallel = async (...items) => {
    const waitAll = async (...items) => {
        //this function does start execution the functions
        //the execution has been started before running this code here
        //instead it collects of the result of execution of the functions

        const temp = [];
        for (const item of items) {
            //this is not
            //temp.push(await item())
            //it does wait for the result in series (not in parallel), but
            //it doesn't affect the parallel execution of those functions
            //because they haven started earlier
            temp.push(await item);
        }
        return temp;
    };

    //the async functions are executed in parallel before passed
    //in the waitAll function

    //const finalResult = await waitAll(someResult(), anotherResult());
    //const finalResult = await parallel(someResult(), anotherResult());
    //or
    const [result1, result2] = await waitAll(someResult(), anotherResult());
    //const [result1, result2] = await parallel(someResult(), anotherResult());