re:re:actable
Урок 053 минуты чтения

Задача: ограничение числа параллельных запросов

На этой странице
Кратко

Пул промисов (concurrency limit) выполняет много асинхронных задач, но не больше limit одновременно: как только одна завершается, запускается следующая. Это нужно, чтобы не открыть 500 запросов сразу (лимиты браузера и сервера, rate limiting). Решение: несколько «воркеров», каждый в цикле берет следующую задачу из общей очереди; результаты сохраняются по индексу, чтобы порядок совпадал с исходным.

Вопрос

Реализуйте promisePool(tasks, limit), где tasks — массив функций, возвращающих промисы. Одновременно должно выполняться не больше limit задач, результат — массив в исходном порядке.

Решение: воркеры

async function promisePool(tasks, limit) {
  const results = new Array(tasks.length);
  let nextIndex = 0;
 
  async function worker() {
    while (nextIndex < tasks.length) {
      const index = nextIndex++;                 // взять следующую задачу (JS однопоточный — гонки нет)
      results[index] = await tasks[index]();
    }
  }
 
  const workers = Array.from({ length: Math.min(limit, tasks.length) }, worker);
  await Promise.all(workers);
  return results;
}

Задачи — функции, а не промисы: промис начинает выполняться в момент создания, и ограничить его уже нельзя.

Проверка

const delay = (ms, value) => () =>
  new Promise((resolve) => {
    console.log("старт", value);
    setTimeout(() => { console.log("конец", value); resolve(value); }, ms);
  });
 
const results = await promisePool(
  [delay(300, "a"), delay(100, "b"), delay(250, "c"), delay(100, "d")],
  2,
);
// старт a, старт b       ← сразу две
// 100 мс: конец b → старт c
// 300 мс: конец a → старт d
// 350 мс: конец c
// 400 мс: конец d
// results: ["a", "b", "c", "d"] — исходный порядок

Вариант с allSettled-поведением

Если одна задача упала, Promise.all в решении выше отклонится, но остальные воркеры продолжат работу. Часто нужно собрать все результаты:

async function promisePoolSettled(tasks, limit) {
  const results = new Array(tasks.length);
  let nextIndex = 0;
 
  async function worker() {
    while (nextIndex < tasks.length) {
      const index = nextIndex++;
      try {
        results[index] = { status: "fulfilled", value: await tasks[index]() };
      } catch (reason) {
        results[index] = { status: "rejected", reason };
      }
    }
  }
 
  await Promise.all(Array.from({ length: Math.min(limit, tasks.length) }, worker));
  return results;
}

Вариант: функция-ограничитель (как p-limit)

function createLimiter(limit) {
  let active = 0;
  const queue = [];
 
  const next = () => {
    if (active >= limit || queue.length === 0) return;
    active += 1;
    const { task, resolve, reject } = queue.shift();
    task().then(resolve, reject).finally(() => {
      active -= 1;
      next();
    });
  };
 
  return (task) =>
    new Promise((resolve, reject) => {
      queue.push({ task, resolve, reject });
      next();
    });
}
 
const limit = createLimiter(3);
const urls = Array.from({ length: 20 }, (_, i) => `/api/items/${i}`);
const data = await Promise.all(urls.map((url) => limit(() => fetch(url).then((r) => r.json()))));

Ограничитель удобен, когда задачи появляются постепенно (загрузка файлов по мере выбора), а не известны заранее.

Доп. вопросы интервьюера

  • Почему задачи — функции? чтобы управлять моментом запуска.
  • Есть ли гонка при nextIndex++? нет: JavaScript выполняет код в одном потоке, инкремент происходит синхронно между await.
  • Как добавить отмену? проверять signal.aborted перед взятием следующей задачи и передавать signal в задачи.
  • Сложность? время ≈ сумма длительностей / limit, память O(n).

Что важно помнить

  • Результаты по индексу — порядок исходный.
  • Math.min(limit, tasks.length) — не создавать лишних воркеров.
  • Решите, что делать при ошибке: остановить всё или собрать статусы.
  • В браузере на HTTP/1.1 есть свой лимит ~6 соединений на домен — пул все равно полезен для контроля нагрузки и порядка.

Мини-шпаргалка

Пул: limit воркеров, каждый while (next < n) { const i = next++; results[i] = await tasks[i]() }, затем Promise.all(workers). Задачи — функции. Ограничитель: active, queue, next() после finally. Ошибки — fail fast или статусы как в allSettled.

Документация

MDN: Using promises, p-limit, MDN: Promise.all().

Дочитали до конца?
Отметьте урок — прогресс сохранится в браузере.

Поиск

Поиск по урокам