เรียก async / ฟังก์ชั่นที่รอคอยในแบบคู่ขนาน

เท่าที่ฉันเข้าใจใน ES7 / ES2016 การใส่รหัสหลายรายการawaitจะทำงานคล้ายกับการผูกมัด.then()กับสัญญาซึ่งหมายความว่าพวกเขาจะดำเนินการอย่างใดอย่างหนึ่งหลังจากที่อื่นมากกว่าใน Parallerl ตัวอย่างเช่นเรามีรหัสนี้:

await someCall();
await anotherCall();

ฉันเข้าใจถูกต้องหรือไม่ว่าanotherCall()จะถูกเรียกเมื่อsomeCall()เสร็จสิ้นเท่านั้น อะไรคือวิธีที่สวยงามที่สุดในการโทรหาพวกเขาในแบบคู่ขนาน?

ฉันต้องการใช้มันในโหนดดังนั้นอาจมีวิธีแก้ปัญหาด้วยไลบรารี async หรือไม่?

แก้ไข: ฉันไม่พอใจกับวิธีแก้ปัญหาที่ให้ไว้ในคำถามนี้: การชะลอตัวเนื่องจากการรอคอยสัญญาแบบไม่ต่อเนื่องในเครื่องกำเนิดไฟฟ้า asyncเนื่องจากมันใช้เครื่องกำเนิดไฟฟ้าและฉันกำลังถามกรณีการใช้งานทั่วไปมากกว่า

คุณสามารถรอที่Promise.all():

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

วิธีเก็บผลลัพธ์:

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

โปรดทราบว่าPromise.allล้มเหลวอย่างรวดเร็วซึ่งหมายความว่าทันทีที่สัญญาข้อใดข้อหนึ่งที่ให้ไว้นั้นถูกปฏิเสธแล้วสิ่งทั้งปวงก็ปฏิเสธ

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'

หาก Promise.allSettledแต่คุณต้องการที่จะรอสำหรับทุกสัญญาที่ให้ทั้งตอบสนองหรือปฏิเสธแล้วคุณสามารถใช้ โปรดทราบว่า Internet Explorer ไม่สนับสนุนวิธีการนี้

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

ใช้Promise.allสำหรับการเรียกฟังก์ชั่นแบบขนานพฤติกรรมการตอบรับไม่ถูกต้องเมื่อเกิดข้อผิดพลาด

ขั้นแรกให้ดำเนินการเรียกแบบอะซิงโครนัสทั้งหมดในครั้งเดียวและรับPromiseวัตถุทั้งหมด ประการที่สองใช้awaitกับPromiseวัตถุ วิธีนี้ในขณะที่คุณรอก่อนPromiseเพื่อแก้ไขการโทรแบบอะซิงโครนัสอื่น ๆ ยังคงดำเนินอยู่ โดยรวมแล้วคุณจะรอตราบเท่าที่การโทรแบบอะซิงโครนัสช้าที่สุด ตัวอย่างเช่น:

// 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: http://jsbin.com/xerifanima/edit?js,console

Caveat:มันไม่สำคัญว่าการawaitโทรจะอยู่ในสายเดียวกันหรือต่างสายกันตราบใดที่การawaitโทรครั้งแรกเกิดขึ้นหลังจากการโทรแบบอะซิงโครนัสทั้งหมด ดูความคิดเห็นของ JohnnyHK

ปรับปรุง:คำตอบนี้มีระยะเวลาที่แตกต่างกันในการจัดการข้อผิดพลาดตามที่คำตอบของ @ bergiก็ไม่ไม่โยนออกข้อผิดพลาดเป็นข้อผิดพลาดเกิดขึ้น แต่หลังจากที่สัญญาทั้งหมดจะดำเนินการ ฉันเปรียบเทียบผลลัพธ์กับเคล็ดลับของ @ jonny: [result1, result2] = Promise.all([async1(), async2()])ตรวจสอบข้อมูลโค้ดต่อไปนี้

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

ปรับปรุง:

คำตอบเดิมทำให้ยาก (และในบางกรณีเป็นไปไม่ได้) ที่จะจัดการกับการปฏิเสธสัญญาอย่างถูกต้อง ทางออกที่ถูกต้องคือการใช้Promise.all:

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

คำตอบเดิม:

เพียงให้แน่ใจว่าคุณเรียกฟังก์ชั่นทั้งสองก่อนที่จะรออย่างใดอย่างหนึ่ง:

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

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

มีวิธีอื่นที่ไม่มี Promise.all () ทำแบบขนาน:

อันดับแรกเรามี 2 ฟังก์ชันเพื่อพิมพ์หมายเลข:

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

นี่คือลำดับ:

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

นี่คือขนาน:

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

ซึ่งสามารถทำได้ด้วยPromise.allSettled ()ซึ่งคล้ายกับPromise.all()แต่ไม่มีลักษณะการทำงานที่ล้มเหลวอย่างรวดเร็ว

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

หมายเหตุ : นี่เป็นคุณสมบัติที่มีเลือดออกที่มีการสนับสนุนเบราว์เซอร์ที่ จำกัด ดังนั้นฉันขอแนะนำอย่างยิ่งให้รวม polyfill สำหรับฟังก์ชั่นนี้

ฉันได้สร้างส่วนสำคัญในการทดสอบวิธีการแก้ปัญหาที่แตกต่างกันด้วยผลลัพธ์ การดูตัวเลือกที่ใช้งานอาจเป็นประโยชน์

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

ในขณะที่การตั้งค่า p1, p2 และ p3 นั้นไม่ได้รันคู่ขนานอย่างเคร่งครัด แต่พวกเขาจะไม่ทำการประมวลผลใด ๆ และคุณสามารถดักจับข้อผิดพลาดทางบริบทด้วยการจับ

ในกรณีของฉันฉันมีงานหลายอย่างที่ฉันต้องการทำงานแบบขนาน แต่ฉันต้องทำสิ่งที่แตกต่างกับผลลัพธ์ของงานเหล่านั้น

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

และผลลัพธ์:

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

รอ Promise.all ([someCall (), anotherCall ()]); ดังที่ได้กล่าวมาแล้วจะทำหน้าที่เป็นรั้วด้าย (ทั่วไปมากในขนานรหัสเป็น CUDA) ดังนั้นมันจะช่วยให้สัญญาทั้งหมดในมันทำงานโดยไม่ปิดกั้นซึ่งกันและกัน แต่จะป้องกันไม่ให้การดำเนินการต่อไปจนกว่าจะได้รับการแก้ไขทั้งหมด

อีกวิธีหนึ่งที่คุ้มค่าที่จะแบ่งปันคือ Node.js async ซึ่งจะช่วยให้คุณสามารถควบคุมปริมาณการทำงานพร้อมกันที่มักจะต้องการได้อย่างง่ายดายหากงานเชื่อมโยงโดยตรงกับการใช้ทรัพยากรที่ จำกัด เช่นการเรียก API การดำเนินงาน I / O เป็นต้น

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

มอบเครดิตให้แก่ผู้เขียนบทความระดับกลาง ( อ่านเพิ่มเติม )

ฉันลงคะแนนให้:

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

ระวังในขณะที่คุณเรียกฟังก์ชั่นมันอาจทำให้เกิดผลลัพธ์ที่ไม่คาดคิด:

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

แต่การทำตามจะทำให้คำขอสร้างผู้ใช้ใหม่เสมอ

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

ฉันสร้างฟังก์ชั่นผู้ช่วย waitAll อาจเป็นเพราะมันสามารถทำให้หวานขึ้นได้ ใช้งานได้เฉพาะในnodejsเท่านั้นไม่ใช่ใน Chrome 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());