Panggil fungsi asink / tunggu secara paralel

Sejauh yang saya mengerti, dalam ES7 / ES2016 menempatkan multiple awaitdalam kode akan bekerja sama dengan chaining .then()dengan janji, yang berarti bahwa mereka akan mengeksekusi satu demi satu daripada di parallerl. Jadi, misalnya, kami memiliki kode ini:

await someCall();
await anotherCall();

Apakah saya memahaminya dengan benar yang anotherCall()akan dipanggil hanya ketika someCall()selesai? Apa cara paling elegan untuk memanggil mereka secara paralel?

Saya ingin menggunakannya di Node, jadi mungkin ada solusi dengan pustaka async?

EDIT: Saya tidak puas dengan solusi yang disediakan dalam pertanyaan ini: Perlambatan karena janji yang tidak paralel menunggu di generator async , karena menggunakan generator dan saya bertanya tentang kasus penggunaan yang lebih umum.

Anda bisa menunggu di Promise.all():

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

Untuk menyimpan hasilnya:

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

Perhatikan bahwa Promise.allgagal dengan cepat, yang berarti bahwa begitu salah satu janji yang diberikan kepadanya ditolak, maka semuanya ditolak.

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'

Sebaliknya, jika Anda ingin menunggu semua janji untuk dipenuhi atau ditolak, maka Anda dapat menggunakannya Promise.allSettled. Perhatikan bahwa Internet Explorer tidak mendukung metode ini.

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

Gunakan Promise.alluntuk panggilan fungsi paralel, perilaku jawaban tidak benar ketika kesalahan terjadi.

Pertama, jalankan semua panggilan asinkron sekaligus dan dapatkan semua Promiseobjek. Kedua, gunakan awaitpada Promiseobjek. Dengan cara ini, selagi Anda menunggu yang pertama Promiseuntuk menyelesaikan panggilan asinkron lainnya masih berlangsung. Secara keseluruhan, Anda hanya akan menunggu selama panggilan asinkron paling lambat. Sebagai contoh:

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

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

Peringatan: Tidak masalah jika awaitpanggilan berada di jalur yang sama atau di jalur yang berbeda, selama awaitpanggilan pertama terjadi setelah semua panggilan tidak sinkron. Lihat komentar JohnnyHK.

Pembaruan: jawaban ini memiliki waktu yang berbeda dalam penanganan kesalahan sesuai dengan jawaban @bergi , ia TIDAK membuang kesalahan saat kesalahan terjadi tetapi setelah semua janji dijalankan. Saya membandingkan hasilnya dengan tip @ jonny:, [result1, result2] = Promise.all([async1(), async2()])periksa cuplikan kode berikut

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

Memperbarui:

Jawaban asli menyulitkan (dan dalam beberapa kasus tidak mungkin) untuk menangani penolakan janji dengan benar. Solusi yang benar adalah dengan menggunakan Promise.all:

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

Jawaban asli:

Pastikan Anda memanggil kedua fungsi sebelum menunggu salah satunya:

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

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

Ada cara lain tanpa Promise.all () untuk melakukannya secara paralel:

Pertama, kami memiliki 2 fungsi untuk mencetak angka:

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

Ini berurutan:

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

Ini paralel:

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

Ini dapat dilakukan dengan Promise.allSettled () , yang mirip dengan Promise.all()tetapi tanpa perilaku gagal-cepat.

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

Catatan : Ini adalah fitur tepi berdarah dengan dukungan browser terbatas, jadi saya sangat menyarankan untuk memasukkan polyfill untuk fungsi ini.

Saya telah membuat intisari pengujian beberapa cara berbeda untuk menyelesaikan janji, dengan hasil. Mungkin bermanfaat untuk melihat opsi yang berfungsi.

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

Meskipun pengaturan p1, p2 dan p3 tidak sepenuhnya menjalankannya secara paralel, mereka tidak menahan eksekusi apa pun dan Anda dapat menjebak kesalahan kontekstual dengan tangkapan.

Dalam kasus saya, saya memiliki beberapa tugas yang ingin saya jalankan secara paralel, tetapi saya perlu melakukan sesuatu yang berbeda dengan hasil dari tugas-tugas itu.

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

Dan hasilnya:

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

menunggu Promise.all ([someCall (), anotherCall ()]); seperti yang sudah disebutkan akan bertindak sebagai pagar benang (sangat umum dalam kode paralel sebagai CUDA), maka itu akan memungkinkan semua janji di dalamnya untuk berjalan tanpa saling menghalangi, tetapi akan mencegah eksekusi untuk melanjutkan sampai SEMUA diselesaikan.

pendekatan lain yang layak untuk dibagikan adalah Node.js async yang juga akan memungkinkan Anda untuk dengan mudah mengontrol jumlah konkurensi yang biasanya diinginkan jika tugas terkait langsung dengan penggunaan sumber daya terbatas seperti panggilan API, operasi I / O, dll.

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

Kredit untuk artikel Sedang autor ( baca selengkapnya )

Saya memilih:

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

Waspadai saat Anda memanggil fungsi, itu dapat menyebabkan hasil yang tidak terduga:

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

Namun mengikuti selalu memicu permintaan untuk membuat Pengguna baru

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

Saya membuat fungsi pembantu waitAll, mungkin itu bisa membuatnya lebih manis. Ini hanya berfungsi di nodejs untuk saat ini, bukan di 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());