चुनौती: वादों के साथ शेड्यूलिंग

"शेड्यूलिंग" का अर्थ है यह तय करना कि एसिंक कार्यों की सूची कैसे चलाएँ: सभी एक साथ, एक समय में एक, या छोटे समूहों में. हम Promise.all, for await, और क्लोजर को संयोजित करेंगे।

समानांतर में: सभी एक साथ

जब कार्य स्वतंत्र और तेज़ हों, तो उन सभी को लॉन्च करें और Promise.all के साथ प्रतीक्षा करें:

async function inParallelo(tasks) {
  return Promise.all(tasks.map((t) => t()));
}

const risultati = await inParallelo([
  () => Promise.resolve(1),
  () => Promise.resolve(2),
  () => Promise.resolve(3),
]);
// [1, 2, 3]

कुल समय ≈ सबसे धीमे कार्य का समय।

शृंखला में: एक समय में एक

जब प्रत्येक कार्य पिछले कार्य पर निर्भर हो, या आप दर-सीमा तय करना चाहते हों:

async function inSerie(tasks) {
  const risultati = [];
  for (const t of tasks) {
    risultati.push(await t());
  }
  return risultati;
}

कुल समय ≈ समयों का योग.

एक समवर्ती सीमा के साथ

कभी-कभी आप एक हज़ार समवर्ती अनुरोध नहीं चाहते हैं, लेकिन आप उनके लिए प्रतीक्षा नहीं करना चाहते हैं श्रृंखला या तो: आप उड़ान में अधिकतम एन चाहते हैं।

async function conLimite(tasks, n) {
  const risultati = new Array(tasks.length);
  let i = 0;
  async function worker() {
    while (i < tasks.length) {
      const mio = i++;
      risultati[mio] = await tasks[mio]();
    }
  }
  await Promise.all(Array.from({ length: n }, worker));
  return risultati;
}

विचार: आप n "श्रमिकों" को लॉन्च करते हैं जो अगले सूचकांक को तब तक पकड़ लेते हैं जब तक कि कुछ भी नहीं बचता।

इसे अजमाएं

व्यायाम की समीक्षा करें