Concurrency-patronen in JavaScript: Promise Pools en Rate Limiting

In moderne JavaScript-ontwikkeling is het omgaan met asynchrone operaties een fundamentele vereiste. Of u nu gegevens ophaalt van API's, grote datasets verwerkt of gebruikersinteracties afhandelt, het effectief beheren van concurrency is cruciaal voor prestaties en stabiliteit. Twee krachtige patronen die deze uitdaging aanpakken zijn Promise Pools en Rate Limiting. Dit artikel duikt diep in deze concepten, geeft praktische voorbeelden en laat zien hoe u ze in uw projecten kunt implementeren.

Asynchrone Operaties en Concurrency Begrijpen

JavaScript is van nature single-threaded. Dit betekent dat er slechts één operatie tegelijk kan worden uitgevoerd. De introductie van asynchrone operaties (met technieken zoals callbacks, Promises en async/await) stelt JavaScript echter in staat om meerdere taken gelijktijdig af te handelen zonder de hoofdthread te blokkeren. Concurrency betekent in deze context het beheren van meerdere taken die tegelijkertijd worden uitgevoerd.

Overweeg de volgende scenario's:

• Gegevens tegelijkertijd ophalen van meerdere API's om een dashboard te vullen.
• Een groot aantal afbeeldingen in een batch verwerken.
• Meerdere gebruikersverzoeken afhandelen die database-interacties vereisen.

Zonder goed concurrency-beheer kunt u te maken krijgen met prestatieknelpunten, verhoogde latentie en zelfs instabiliteit van de applicatie. Het bombarderen van een API met te veel verzoeken kan bijvoorbeeld leiden tot 'rate limiting'-fouten of zelfs serviceonderbrekingen. Op dezelfde manier kan het gelijktijdig uitvoeren van te veel CPU-intensieve taken de bronnen van de client of server overweldigen.

Promise Pools: Gelijktijdige Taken Beheren

Een Promise Pool is een mechanisme om het aantal gelijktijdige asynchrone operaties te beperken. Het zorgt ervoor dat er op elk gegeven moment slechts een bepaald aantal taken wordt uitgevoerd, waardoor uitputting van bronnen wordt voorkomen en de responsiviteit wordt gehandhaafd. Dit patroon is met name handig bij het omgaan met een groot aantal onafhankelijke taken die parallel kunnen worden uitgevoerd, maar moeten worden beperkt.

Een Promise Pool Implementeren

Hier is een basisimplementatie van een Promise Pool in 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(); // Verwerk de volgende taak in de wachtrij
      }
    }
  }
}

            

              
                Copy
              
            
          

Uitleg:

• De PromisePool-klasse accepteert een concurrency-parameter, die het maximale aantal taken definieert dat gelijktijdig kan worden uitgevoerd.
• De add-methode voegt een taak (een functie die een Promise retourneert) toe aan de wachtrij. Het retourneert een Promise die wordt vervuld (resolve) of afgewezen (reject) wanneer de taak is voltooid.
• De processQueue-methode controleert of er beschikbare slots zijn (this.running < this.concurrency) en taken in de wachtrij staan. Zo ja, dan haalt het een taak uit de wachtrij, voert deze uit en werkt de running-teller bij.
• Het finally-blok zorgt ervoor dat de running-teller wordt verlaagd en de processQueue-methode opnieuw wordt aangeroepen om de volgende taak in de wachtrij te verwerken, zelfs als de taak mislukt.

Gebruiksvoorbeeld

Stel, u heeft een array met URL's en u wilt gegevens van elke URL ophalen met de fetch API, maar u wilt het aantal gelijktijdige verzoeken beperken om de server niet te overbelasten.

            
async function fetchData(url) {
  console.log(`Gegevens ophalen van ${url}`);
  // Simuleer netwerklatentie
  await new Promise(resolve => setTimeout(resolve, Math.random() * 1000));
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`HTTP-fout! 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); // Beperk concurrency tot 3
  const promises = urls.map(url => pool.add(() => fetchData(url)));

  try {
    const results = await Promise.all(promises);
    console.log('Resultaten:', results);
  } catch (error) {
    console.error('Fout bij ophalen gegevens:', error);
  }
}

main();

            

              
                Copy
              
            
          

In dit voorbeeld wordt de PromisePool geconfigureerd met een concurrency van 3. De urls.map-functie maakt een array van Promises, die elk een taak vertegenwoordigen om gegevens van een specifieke URL op te halen. De pool.add-methode voegt elke taak toe aan de Promise Pool, die de uitvoering van deze taken gelijktijdig beheert en ervoor zorgt dat er op geen enkel moment meer dan 3 verzoeken tegelijk worden uitgevoerd. De Promise.all-functie wacht tot alle taken zijn voltooid en retourneert een array met resultaten.

Rate Limiting: API-misbruik en Overbelasting van Services Voorkomen

Rate limiting is een techniek om de snelheid te beheersen waarmee clients (of gebruikers) verzoeken kunnen doen naar een service of API. Het is essentieel om misbruik te voorkomen, te beschermen tegen denial-of-service (DoS)-aanvallen en eerlijk gebruik van bronnen te garanderen. Rate limiting kan aan de client-side, server-side of beide worden geïmplementeerd.

Waarom Rate Limiting Gebruiken?

• Misbruik Voorkomen: Beperkt het aantal verzoeken dat een enkele gebruiker of client binnen een bepaalde periode kan doen, waardoor wordt voorkomen dat ze de server met buitensporige verzoeken overbelasten.
• Beschermen tegen DoS-aanvallen: Helpt de impact van distributed denial-of-service (DDoS)-aanvallen te verminderen door de snelheid te beperken waarmee aanvallers verzoeken kunnen sturen.
• Eerlijk Gebruik Garanderen: Stelt verschillende gebruikers of clients in staat om eerlijk toegang te krijgen tot bronnen door verzoeken gelijkmatig te verdelen.
• Prestaties Verbeteren: Voorkomt dat de server overbelast raakt, waardoor deze tijdig op verzoeken kan reageren.
• Kostenoptimalisatie: Vermindert het risico op het overschrijden van API-gebruiksquota's en het oplopen van extra kosten van diensten van derden.

Rate Limiting Implementeren in JavaScript

Er zijn verschillende benaderingen om rate limiting in JavaScript te implementeren, elk met zijn eigen afwegingen. Hier zullen we een client-side implementatie verkennen met behulp van een eenvoudig 'token bucket'-algoritme.

            
class RateLimiter {
  constructor(capacity, refillRate, interval) {
    this.capacity = capacity; // Maximaal aantal tokens
    this.tokens = capacity;
    this.refillRate = refillRate; // Tokens toegevoegd per interval
    this.interval = interval; // Interval in milliseconden

    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 overschreden.'));
          }
        }, waitTime);
      });
    }
  }
}

            

              
                Copy
              
            
          

Uitleg:

• De RateLimiter-klasse accepteert drie parameters: capacity (het maximale aantal tokens), refillRate (het aantal tokens dat per interval wordt toegevoegd), en interval (het tijdsinterval in milliseconden).
• De refill-methode voegt tokens toe aan de 'bucket' met een snelheid van refillRate per interval, tot aan de maximale capaciteit.
• De consume-methode probeert een opgegeven aantal tokens te verbruiken (standaard 1). Als er voldoende tokens beschikbaar zijn, verbruikt het deze en wordt de promise onmiddellijk vervuld. Anders berekent het de wachttijd totdat er voldoende tokens beschikbaar zijn, wacht die tijd, en probeert dan opnieuw de tokens te verbruiken. Als er dan nog steeds niet genoeg tokens zijn, wordt de promise afgewezen met een fout.

Gebruiksvoorbeeld

            
async function makeApiRequest() {
  // Simuleer API-verzoek
  await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
  console.log('API-verzoek succesvol');
}

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

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

main();

            

              
                Copy
              
            
          

In dit voorbeeld is de RateLimiter geconfigureerd om 5 verzoeken per seconde toe te staan. De main-functie doet 10 API-verzoeken, die elk worden voorafgegaan door een aanroep van rateLimiter.consume(). Als de limiet wordt overschreden, zal de consume-methode de promise afwijzen met een fout, die wordt opgevangen door het try...catch-blok.

Promise Pools en Rate Limiting Combineren

In sommige scenario's wilt u misschien Promise Pools en Rate Limiting combineren om een meer granulaire controle over concurrency en verzoeksnelheden te bereiken. U wilt bijvoorbeeld het aantal gelijktijdige verzoeken naar een specifiek API-eindpunt beperken, terwijl u er ook voor zorgt dat de algehele verzoeksnelheid een bepaalde drempel niet overschrijdt.

Zo kunt u deze twee patronen combineren:

            
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); // Beperk concurrency tot 3
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 verzoeken per seconde

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

  try {
    const results = await Promise.all(promises);
    console.log('Resultaten:', results);
  } catch (error) {
    console.error('Fout bij ophalen gegevens:', error);
  }
}

main();

            

              
                Copy
              
            
          

In dit voorbeeld verbruikt de fetchDataWithRateLimit-functie eerst een token van de RateLimiter voordat de gegevens van de URL worden opgehaald. Dit zorgt ervoor dat de verzoeksnelheid wordt beperkt, ongeacht het concurrency-niveau dat wordt beheerd door de PromisePool.

Overwegingen voor Wereldwijde Applicaties

Bij het implementeren van Promise Pools en Rate Limiting in wereldwijde applicaties is het belangrijk om rekening te houden met de volgende factoren:

• Tijdzones: Houd rekening met tijdzones bij het implementeren van rate limiting. Zorg ervoor dat uw rate limiting-logica is gebaseerd op een consistente tijdzone of een tijdzone-agnostische aanpak gebruikt (bijv. UTC).
• Geografische Spreiding: Als uw applicatie in meerdere geografische regio's wordt ingezet, overweeg dan om rate limiting per regio te implementeren om rekening te houden met verschillen in netwerklatentie en gebruikersgedrag. Content Delivery Networks (CDN's) bieden vaak rate limiting-functies die aan de 'edge' kunnen worden geconfigureerd.
• Rate Limiting van API-providers: Wees u bewust van de limieten die worden opgelegd door API's van derden die uw applicatie gebruikt. Implementeer uw eigen rate limiting-logica om binnen deze limieten te blijven en blokkades te voorkomen. Overweeg het gebruik van 'exponential backoff with jitter' om op een elegante manier met rate limiting-fouten om te gaan.
• Gebruikerservaring: Geef informatieve foutmeldingen aan gebruikers wanneer ze te maken krijgen met rate limiting, waarin de reden voor de beperking wordt uitgelegd en hoe ze dit in de toekomst kunnen vermijden. Overweeg verschillende serviceniveaus aan te bieden met variërende limieten om aan verschillende gebruikersbehoeften te voldoen.
• Monitoring en Logging: Monitor de concurrency en verzoeksnelheden van uw applicatie om potentiële knelpunten te identificeren en ervoor te zorgen dat uw rate limiting-logica effectief is. Log relevante statistieken om gebruikspatronen te volgen en mogelijk misbruik te identificeren.

Conclusie

Promise Pools en Rate Limiting zijn krachtige hulpmiddelen voor het beheren van concurrency en het voorkomen van overbelasting in JavaScript-applicaties. Door deze patronen te begrijpen en effectief te implementeren, kunt u de prestaties, stabiliteit en schaalbaarheid van uw applicaties verbeteren. Of u nu een eenvoudige webapplicatie of een complex gedistribueerd systeem bouwt, het beheersen van deze concepten is essentieel voor het bouwen van robuuste en betrouwbare software.

Vergeet niet om de specifieke vereisten van uw applicatie zorgvuldig te overwegen en de juiste strategie voor concurrency-beheer te kiezen. Experimenteer met verschillende configuraties om de optimale balans te vinden tussen prestaties en resourcegebruik. Met een solide begrip van Promise Pools en Rate Limiting bent u goed uitgerust om de uitdagingen van moderne JavaScript-ontwikkeling aan te gaan.