Provocare: programarea cu Promises

"Scheduling" means deciding how to run a list of async tasks: all together, one at a time, or in small groups. We will combine Promise.all, for await, and closures.

In parallel: all together

When tasks are independent and fast, launch them all and wait with 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]

Total time ≈ time of the slowest task.

In series: one at a time

When each task depends on the previous one, or you want to rate-limit:

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

Total time ≈ sum of the times.

With a concurrency limit

Sometimes you do not want a thousand concurrent requests, but you do not want to wait for them in series either: you want a maximum of N in flight.

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

The idea: you launch n "workers" that grab the next index until there is nothing left.

Try it

Review exercise