Appeler les fonctions asynchrones / attente en parallèle

Pour autant que je sache, dans ES7 / ES2016, mettre plusieurs awaitdans le code fonctionnera de manière similaire au chaînage .then()avec des promesses, ce qui signifie qu'ils s'exécuteront les uns après les autres plutôt qu'en parallèle. Ainsi, par exemple, nous avons ce code:

await someCall();
await anotherCall();

Dois-je comprendre correctement que anotherCall()sera appelé uniquement une fois someCall()terminé? Quelle est la manière la plus élégante de les appeler en parallèle?

Je veux l'utiliser dans Node, alors peut-être qu'il y a une solution avec la bibliothèque asynchrone?

EDIT: Je ne suis pas satisfait de la solution fournie dans cette question: Ralentissement dû à l'attente non parallèle de promesses dans les générateurs asynchrones , car il utilise des générateurs et je pose des questions sur un cas d'utilisation plus général.

Vous pouvez attendre sur Promise.all():

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

Pour stocker les résultats:

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

Notez que cela Promise.alléchoue rapidement, ce qui signifie que dès qu'une des promesses qui lui sont faites rejette, alors la chose entière rejette.

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'

Si, à la place, vous voulez attendre que toutes les promesses soient tenues ou rejetées, vous pouvez utiliser Promise.allSettled. Notez qu'Internet Explorer ne prend pas en charge nativement cette méthode.

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

Utilisez Promise.allpour les appels de fonctions parallèles, les comportements de réponse ne sont pas correctement lorsque l'erreur se produit.

Tout d'abord, exécutez tous les appels asynchrones à la fois et obtenez tous les Promiseobjets. Deuxièmement, utilisez awaitsur les Promiseobjets. De cette façon, pendant que vous attendez que le premier Promiserésolve les autres appels asynchrones progressent toujours. Dans l'ensemble, vous n'attendez que le temps de l'appel asynchrone le plus lent. Par exemple:

// 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

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

Mise en garde: Peu importe si les awaitappels sont sur la même ligne ou sur des lignes différentes, tant que le premier awaitappel se produit après tous les appels asynchrones. Voir le commentaire de JohnnyHK.

Mise à jour: cette réponse a un timing différent dans la gestion des erreurs selon la réponse de @ bergi , elle ne jette PAS l'erreur car l'erreur se produit mais après que toutes les promesses ont été exécutées. Je compare le résultat avec le conseil de @ jonny:, [result1, result2] = Promise.all([async1(), async2()])vérifiez l'extrait de code suivant

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();
})();

Mise à jour:

La réponse originale rend difficile (et dans certains cas impossible) de gérer correctement les refus de promesse. La bonne solution consiste à utiliser Promise.all:

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

Réponse originale:

Assurez-vous simplement d'appeler les deux fonctions avant d'attendre l'une ou l'autre:

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

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

Il existe une autre façon sans Promise.all () de le faire en parallèle:

Tout d'abord, nous avons 2 fonctions pour imprimer les nombres:

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);
   });
}

C'est séquentiel:

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

C'est parallèle:

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

Cela peut être accompli avec Promise.allSettled () , qui est similaire Promise.all()mais sans le comportement de sécurité rapide.

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!"}

Remarque : Il s'agit d'une fonctionnalité de pointe avec une prise en charge limitée du navigateur, je recommande donc fortement d' inclure un polyfill pour cette fonction.

J'ai créé un résumé testant différentes façons de résoudre les promesses, avec des résultats. Il peut être utile de voir les options qui fonctionnent.

    // 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
    */

Bien que définir p1, p2 et p3 ne les exécute pas strictement en parallèle, ils ne bloquent aucune exécution et vous pouvez intercepter les erreurs contextuelles avec un catch.

Dans mon cas, j'ai plusieurs tâches que je veux exécuter en parallèle, mais je dois faire quelque chose de différent avec le résultat de ces tâches.

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');

Et la sortie:

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

attendre Promise.all ([someCall (), anotherCall ()]); comme déjà mentionné agira comme une barrière de thread (très courant dans le code parallèle comme CUDA), donc il permettra à toutes les promesses qu'il contient de s'exécuter sans se bloquer, mais empêchera l'exécution de continuer jusqu'à ce que TOUS soient résolus.

une autre approche qui mérite d'être partagée est l'async Node.js qui vous permettra également de contrôler facilement la quantité de simultanéité qui est généralement souhaitable si la tâche est directement liée à l'utilisation de ressources limitées comme appel API, opérations d'E / S, etc.

// 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');
});

Crédits à l'auteur de l'article Medium (en savoir plus )

Je vote pour:

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

Soyez conscient du moment où vous appelez des fonctions, cela peut entraîner un résultat inattendu:

// 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
}

Mais le suivi déclenche toujours une demande de création d'un nouvel utilisateur

// 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]
}

Je crée une fonction d'aide waitAll, peut-être que cela peut la rendre plus douce. Cela ne fonctionne que dans nodejs pour l'instant, pas dans le chrome du navigateur.

    //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());