Патерни конкурентності в JavaScript: Пули промісів та обмеження частоти запитів

У сучасній JavaScript-розробці робота з асинхронними операціями є фундаментальною вимогою. Незалежно від того, чи ви отримуєте дані з API, обробляєте великі набори даних, чи керуєте взаємодією з користувачем, ефективне управління конкурентністю є ключовим для продуктивності та стабільності. Два потужні патерни, що вирішують цю проблему, — це Пули промісів та Обмеження частоти запитів. У цій статті ми глибоко зануримося в ці концепції, надаючи практичні приклади та демонструючи, як їх реалізувати у ваших проєктах.

Розуміння асинхронних операцій та конкурентності

JavaScript за своєю природою є однопоточним. Це означає, що одночасно може виконуватися лише одна операція. Однак, запровадження асинхронних операцій (з використанням таких технік, як колбеки, проміси та async/await) дозволяє JavaScript обробляти кілька завдань конкурентно, не блокуючи головний потік. Конкурентність у цьому контексті означає керування кількома завданнями, що виконуються одночасно.

Розглянемо такі сценарії:

• Одночасне отримання даних з кількох API для заповнення дашборду.
• Пакетна обробка великої кількості зображень.
• Обробка кількох запитів користувачів, які потребують взаємодії з базою даних.

Без належного керування конкурентністю ви можете зіткнутися з вузькими місцями у продуктивності, збільшеною затримкою і навіть нестабільністю застосунку. Наприклад, бомбардування API занадто великою кількістю запитів може призвести до помилок обмеження частоти або навіть збоїв у роботі сервісу. Аналогічно, одночасне виконання занадто багатьох завдань, що інтенсивно використовують процесор, може перевантажити ресурси клієнта або сервера.

Пули промісів: Керування конкурентними завданнями

Пул промісів — це механізм для обмеження кількості одночасних асинхронних операцій. Він гарантує, що в будь-який момент часу виконується лише певна кількість завдань, запобігаючи вичерпанню ресурсів та підтримуючи швидкість реакції. Цей патерн особливо корисний при роботі з великою кількістю незалежних завдань, які можна виконувати паралельно, але їхню кількість потрібно регулювати.

Реалізація пулу промісів

Ось базова реалізація пулу промісів у JavaScript:

            
class PromisePool {
  constructor(concurrency) {
    this.concurrency = concurrency;
    this.running = 0;
    this.queue = [];
  }

  async add(task) {
    return new Promise((resolve, reject) => {
      this.queue.push({ task, resolve, reject });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.running < this.concurrency && this.queue.length) {
      const { task, resolve, reject } = this.queue.shift();
      this.running++;

      try {
        const result = await task();
        resolve(result);
      } catch (error) {
        reject(error);
      } finally {
        this.running--;
        this.processQueue(); // Process the next task in the queue
      }
    }
  }
}

            

              
                Copy
              
            
          

Пояснення:

• Клас PromisePool приймає параметр concurrency, який визначає максимальну кількість завдань, що можуть виконуватися одночасно.
• Метод add додає завдання (функцію, що повертає проміс) до черги. Він повертає проміс, який буде виконано або відхилено після завершення завдання.
• Метод processQueue перевіряє, чи є вільні слоти (this.running < this.concurrency) та завдання в черзі. Якщо так, він вилучає завдання з черги, виконує його та оновлює лічильник running.
• Блок finally гарантує, що лічильник running буде зменшено, а метод processQueue буде викликано знову для обробки наступного завдання в черзі, навіть якщо завдання завершиться з помилкою.

Приклад використання

Припустимо, у вас є масив URL-адрес, і ви хочете отримати дані з кожної URL-адреси за допомогою API fetch, але ви хочете обмежити кількість одночасних запитів, щоб не перевантажувати сервер.

            
async function fetchData(url) {
  console.log(`Fetching data from ${url}`);
  // Simulate network latency
  await new Promise(resolve => setTimeout(resolve, Math.random() * 1000));
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  return await response.json();
}

async function main() {
  const urls = [
    'https://jsonplaceholder.typicode.com/todos/1',
    'https://jsonplaceholder.typicode.com/todos/2',
    'https://jsonplaceholder.typicode.com/todos/3',
    'https://jsonplaceholder.typicode.com/todos/4',
    'https://jsonplaceholder.typicode.com/todos/5',
    'https://jsonplaceholder.typicode.com/todos/6',
    'https://jsonplaceholder.typicode.com/todos/7',
    'https://jsonplaceholder.typicode.com/todos/8',
    'https://jsonplaceholder.typicode.com/todos/9',
    'https://jsonplaceholder.typicode.com/todos/10',
  ];

  const pool = new PromisePool(3); // Limit concurrency to 3
  const promises = urls.map(url => pool.add(() => fetchData(url)));

  try {
    const results = await Promise.all(promises);
    console.log('Results:', results);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

main();

            

              
                Copy
              
            
          

У цьому прикладі PromisePool налаштований на конкурентність 3. Функція urls.map створює масив промісів, кожен з яких представляє завдання на отримання даних з певної URL-адреси. Метод pool.add додає кожне завдання до пулу промісів, який керує виконанням цих завдань конкурентно, гарантуючи, що одночасно виконується не більше 3 запитів. Функція Promise.all очікує завершення всіх завдань і повертає масив результатів.

Обмеження частоти запитів: Запобігання зловживанням API та перевантаженню сервісу

Обмеження частоти запитів — це техніка для контролю швидкості, з якою клієнти (або користувачі) можуть робити запити до сервісу чи API. Це важливо для запобігання зловживанням, захисту від атак типу «відмова в обслуговуванні» (DoS) та забезпечення справедливого використання ресурсів. Обмеження частоти запитів може бути реалізовано на стороні клієнта, на стороні сервера або на обох.

Навіщо використовувати обмеження частоти запитів?

• Запобігання зловживанням: Обмежує кількість запитів, які один користувач або клієнт може зробити за певний проміжок часу, не дозволяючи їм перевантажувати сервер надмірними запитами.
• Захист від DoS-атак: Допомагає пом'якшити вплив розподілених атак типу «відмова в обслуговуванні» (DDoS), обмежуючи швидкість, з якою зловмисники можуть надсилати запити.
• Забезпечення справедливого використання: Дозволяє різним користувачам або клієнтам справедливо отримувати доступ до ресурсів, рівномірно розподіляючи запити.
• Покращення продуктивності: Запобігає перевантаженню сервера, гарантуючи, що він може своєчасно відповідати на запити.
• Оптимізація витрат: Зменшує ризик перевищення квот на використання API та виникнення додаткових витрат від сторонніх сервісів.

Реалізація обмеження частоти запитів у JavaScript

Існують різні підходи до реалізації обмеження частоти запитів у JavaScript, кожен зі своїми перевагами та недоліками. Тут ми розглянемо реалізацію на стороні клієнта з використанням простого алгоритму «token bucket» (кошик з токенами).

            
class RateLimiter {
  constructor(capacity, refillRate, interval) {
    this.capacity = capacity; // Maximum number of tokens
    this.tokens = capacity;
    this.refillRate = refillRate; // Tokens added per interval
    this.interval = interval; // Interval in milliseconds

    setInterval(() => {
      this.refill();
    }, this.interval);
  }

  refill() {
    this.tokens = Math.min(this.capacity, this.tokens + this.refillRate);
  }

  async consume(cost = 1) {
    if (this.tokens >= cost) {
      this.tokens -= cost;
      return Promise.resolve();
    } else {
      return new Promise((resolve, reject) => {
        const waitTime = Math.ceil((cost - this.tokens) / this.refillRate) * this.interval;
        setTimeout(() => {
          if (this.tokens >= cost) {
            this.tokens -= cost;
            resolve();
          } else {
            reject(new Error('Rate limit exceeded.'));
          }
        }, waitTime);
      });
    }
  }
}

            

              
                Copy
              
            
          

Пояснення:

• Клас RateLimiter приймає три параметри: capacity (максимальна кількість токенів), refillRate (кількість токенів, що додаються за інтервал) та interval (часовий інтервал у мілісекундах).
• Метод refill додає токени до кошика зі швидкістю refillRate за interval, до максимальної ємності.
• Метод consume намагається використати вказану кількість токенів (за замовчуванням 1). Якщо токенів достатньо, він їх використовує і негайно виконується. В іншому випадку, він обчислює час очікування до появи достатньої кількості токенів, чекає цей час, а потім знову намагається використати токени. Якщо токенів все ще недостатньо, він відхиляє проміс з помилкою.

Приклад використання

            
async function makeApiRequest() {
  // Simulate API request
  await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
  console.log('API request successful');
}

async function main() {
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 requests per second

  for (let i = 0; i < 10; i++) {
    try {
      await rateLimiter.consume();
      await makeApiRequest();
    } catch (error) {
      console.error('Rate limit exceeded:', error.message);
    }
  }
}

main();

            

              
                Copy
              
            
          

У цьому прикладі RateLimiter налаштований на дозвіл 5 запитів на секунду. Функція main робить 10 запитів до API, кожному з яких передує виклик rateLimiter.consume(). Якщо ліміт частоти запитів перевищено, метод consume відхилить проміс з помилкою, яка буде перехоплена блоком try...catch.

Поєднання пулів промісів та обмеження частоти запитів

У деяких сценаріях ви можете захотіти поєднати пули промісів та обмеження частоти запитів для досягнення більш детального контролю над конкурентністю та швидкістю запитів. Наприклад, ви можете обмежити кількість одночасних запитів до конкретної кінцевої точки API, одночасно гарантуючи, що загальна швидкість запитів не перевищує певного порогу.

Ось як можна поєднати ці два патерни:

            
async function fetchDataWithRateLimit(url, rateLimiter) {
  try {
    await rateLimiter.consume();
    return await fetchData(url);
  } catch (error) {
    throw error;
  }
}

async function main() {
  const urls = [
    'https://jsonplaceholder.typicode.com/todos/1',
    'https://jsonplaceholder.typicode.com/todos/2',
    'https://jsonplaceholder.typicode.com/todos/3',
    'https://jsonplaceholder.typicode.com/todos/4',
    'https://jsonplaceholder.typicode.com/todos/5',
    'https://jsonplaceholder.typicode.com/todos/6',
    'https://jsonplaceholder.typicode.com/todos/7',
    'https://jsonplaceholder.typicode.com/todos/8',
    'https://jsonplaceholder.typicode.com/todos/9',
    'https://jsonplaceholder.typicode.com/todos/10',
  ];

  const pool = new PromisePool(3); // Limit concurrency to 3
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 requests per second

  const promises = urls.map(url => pool.add(() => fetchDataWithRateLimit(url, rateLimiter)));

  try {
    const results = await Promise.all(promises);
    console.log('Results:', results);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

main();

            

              
                Copy
              
            
          

У цьому прикладі функція fetchDataWithRateLimit спочатку використовує токен з RateLimiter перед отриманням даних з URL. Це гарантує, що швидкість запитів обмежена, незалежно від рівня конкурентності, керованого PromisePool.

Рекомендації для глобальних застосунків

При реалізації пулів промісів та обмеження частоти запитів у глобальних застосунках важливо враховувати наступні фактори:

• Часові пояси: Пам'ятайте про часові пояси при реалізації обмеження частоти запитів. Переконайтеся, що ваша логіка обмеження базується на узгодженому часовому поясі або використовує незалежний від часового поясу підхід (наприклад, UTC).
• Географічний розподіл: Якщо ваш застосунок розгорнуто в кількох географічних регіонах, розгляньте можливість реалізації обмеження частоти запитів для кожного регіону окремо, щоб врахувати відмінності в затримці мережі та поведінці користувачів. Мережі доставки контенту (CDN) часто пропонують функції обмеження частоти, які можна налаштувати на межі мережі.
• Ліміти частоти від постачальників API: Будьте в курсі лімітів, встановлених сторонніми API, які використовує ваш застосунок. Реалізуйте власну логіку обмеження частоти, щоб залишатися в межах цих лімітів і уникнути блокування. Розгляньте використання експоненційної затримки з джиттером для коректної обробки помилок обмеження.
• Досвід користувача: Надавайте інформативні повідомлення про помилки користувачам, коли вони досягають ліміту, пояснюючи причину обмеження та як уникнути цього в майбутньому. Розгляньте можливість пропонувати різні рівні обслуговування з різними лімітами частоти для задоволення потреб різних користувачів.
• Моніторинг та логування: Відстежуйте конкурентність та частоту запитів у вашому застосунку, щоб виявляти потенційні вузькі місця та переконуватися, що ваша логіка обмеження є ефективною. Логуйте відповідні метрики для відстеження патернів використання та виявлення можливих зловживань.

Висновок

Пули промісів та обмеження частоти запитів є потужними інструментами для керування конкурентністю та запобігання перевантаженню в застосунках на JavaScript. Розуміючи ці патерни та ефективно їх реалізуючи, ви можете покращити продуктивність, стабільність та масштабованість ваших застосунків. Незалежно від того, чи ви створюєте простий веб-застосунок, чи складну розподілену систему, володіння цими концепціями є важливим для створення надійного та стабільного програмного забезпечення.

Не забувайте ретельно враховувати конкретні вимоги вашого застосунку та обирати відповідну стратегію керування конкурентністю. Експериментуйте з різними конфігураціями, щоб знайти оптимальний баланс між продуктивністю та використанням ресурсів. Маючи тверде розуміння пулів промісів та обмеження частоти запитів, ви будете добре підготовлені до вирішення викликів сучасної JavaScript-розробки.