Chamar funções assíncronas / aguardar em paralelo

Tanto quanto eu entendo, no ES7 / ES2016, colocar múltiplos await's em código funcionará de maneira semelhante ao encadeamento de .then()promessas, o que significa que eles serão executados um após o outro e não em paralelo. Então, por exemplo, temos este código:

await someCall();
await anotherCall();

Entendi corretamente que anotherCall()só será chamado quando someCall()for concluído? Qual é a maneira mais elegante de chamá-los em paralelo?

Eu quero usá-lo no Node, então talvez haja uma solução com a biblioteca assíncrona?

EDIT: Não estou satisfeito com a solução fornecida nesta pergunta: Desaceleração devido à espera paralela de promessas em geradores assíncronos , porque ele usa geradores e estou perguntando sobre um caso de uso mais geral.

Você pode aguardar em Promise.all():

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

Para armazenar os resultados:

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

Observe que Promise.allfalha rapidamente, o que significa que, assim que uma das promessas fornecidas a ele for rejeitada, a coisa toda será rejeitada.

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'

Se, em vez disso, você desejar aguardar todas as promessas cumpridas ou rejeitadas, poderá usá-lo Promise.allSettled. Observe que o Internet Explorer não oferece suporte nativamente a esse método.

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

Use Promise.allpara chamadas de função paralelas, o comportamento da resposta não está correto quando o erro ocorre.

Primeiro, execute todas as chamadas assíncronas de uma só vez e obtenha todos os Promiseobjetos. Segundo, use awaitnos Promiseobjetos. Dessa forma, enquanto você espera pela primeira Promisesolução, as outras chamadas assíncronas ainda estão em andamento. No geral, você só esperará enquanto a chamada assíncrona mais lenta. Por exemplo:

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

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

Advertência: não importa se as awaitchamadas estão na mesma linha ou em linhas diferentes, desde que a primeira awaitchamada ocorra após todas as chamadas assíncronas. Veja o comentário de JohnnyHK.

Atualização: esta resposta tem um tempo diferente no tratamento de erros, de acordo com a resposta do @ bergi , NÃO lança o erro à medida que o erro ocorre, mas depois que todas as promessas são executadas. Comparo o resultado com a dica de @ jonny:, [result1, result2] = Promise.all([async1(), async2()])verifique o seguinte snippet de código

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

Atualizar:

A resposta original torna difícil (e em alguns casos impossível) lidar corretamente com as rejeições de promessas. A solução correta é usar Promise.all:

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

Resposta original:

Apenas certifique-se de chamar as duas funções antes de aguardar uma:

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

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

Existe outra maneira, sem Promise.all (), de fazer isso em paralelo:

Primeiro, temos 2 funções para imprimir números:

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

Isso é seqüencial:

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

Isto é paralelo:

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

Isso pode ser feito com Promise.allSettled () , que é semelhante, Promise.all()mas sem o comportamento à prova de falhas.

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

Nota : Esta é uma característica borda do sangramento com suporte ao navegador limitado, então eu fortemente recomendo incluindo um polyfill para esta função.

Eu criei uma essência testando maneiras diferentes de resolver promessas, com resultados. Pode ser útil ver as opções que funcionam.

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

Embora a configuração de p1, p2 e p3 não os execute estritamente em paralelo, eles não suportam nenhuma execução e você pode capturar erros contextuais com uma captura.

No meu caso, tenho várias tarefas que quero executar em paralelo, mas preciso fazer algo diferente com o resultado dessas tarefas.

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

E a saída:

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

aguarde Promise.all ([someCall (), anotherCall ()]); como já mencionado, ele funcionará como uma cerca de encadeamento (muito comum em código paralelo como CUDA), portanto, permitirá que todas as promessas sejam executadas sem bloquear uma à outra, mas impedirá a execução de continuar até que TODAS sejam resolvidas.

outra abordagem que vale a pena compartilhar é o Node.js. assíncrono que também permitirá que você controle facilmente a quantidade de simultaneidade que normalmente é desejável se a tarefa estiver diretamente vinculada ao uso de recursos limitados como chamada de API, operações de 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éditos ao autor do artigo Medium ( leia mais )

Eu voto em:

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

Esteja ciente do momento em que você chama funções, isso pode causar resultados inesperados:

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

Mas seguir sempre aciona a solicitação para criar um novo usuário

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

Eu crio uma função auxiliar waitAll, pode ser que possa torná-la mais doce. Por enquanto, ele só funciona no nodejs , não no chrome do navegador.

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