Samtidighetsmønstre i JavaScript: Promise-pooler og rategrensing

I moderne JavaScript-utvikling er håndtering av asynkrone operasjoner et grunnleggende krav. Enten du henter data fra API-er, behandler store datasett eller håndterer brukerinteraksjoner, er effektiv styring av samtidighet avgjørende for ytelse og stabilitet. To kraftige mønstre som løser denne utfordringen er Promise-pooler og Rategrensing. Denne artikkelen dykker dypt ned i disse konseptene, gir praktiske eksempler og demonstrerer hvordan du kan implementere dem i dine prosjekter.

Forståelse av asynkrone operasjoner og samtidighet

JavaScript er i sin natur enkelttrådet. Dette betyr at bare én operasjon kan utføres om gangen. Introduksjonen av asynkrone operasjoner (ved hjelp av teknikker som callbacks, Promises og async/await) gjør det imidlertid mulig for JavaScript å håndtere flere oppgaver samtidig uten å blokkere hovedtråden. Samtidighet betyr i denne sammenhengen å håndtere flere pågående oppgaver simultant.

Se for deg disse scenarioene:

• Hente data fra flere API-er samtidig for å fylle et dashbord.
• Behandle et stort antall bilder i en batch.
• Håndtere flere brukerforespørsler som krever databaseinteraksjoner.

Uten riktig samtidighetshåndtering kan du støte på ytelsesflaskehalser, økt ventetid og til og med applikasjonsustabilitet. For eksempel kan det å bombardere et API med for mange forespørsler føre til feilmeldinger om rategrensing eller til og med tjenestebrudd. Tilsvarende kan det å kjøre for mange CPU-intensive oppgaver samtidig overvelde klientens eller serverens ressurser.

Promise-pooler: Håndtering av samtidige oppgaver

En Promise-pool er en mekanisme for å begrense antall samtidige asynkrone operasjoner. Den sikrer at bare et visst antall oppgaver kjører til enhver tid, noe som forhindrer ressursutmattelse og opprettholder responsivitet. Dette mønsteret er spesielt nyttig når man håndterer et stort antall uavhengige oppgaver som kan utføres parallelt, men som må strupes.

Implementering av en Promise-pool

Her er en grunnleggende implementering av en Promise-pool i 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(); // Behandle neste oppgave i køen
      }
    }
  }
}

            

              
                Copy
              
            
          

Forklaring:

• PromisePool-klassen tar en concurrency-parameter, som definerer det maksimale antallet oppgaver som kan kjøre samtidig.
• add-metoden legger til en oppgave (en funksjon som returnerer et Promise) i køen. Den returnerer et Promise som vil bli løst eller avvist når oppgaven er fullført.
• processQueue-metoden sjekker om det er ledige plasser (this.running < this.concurrency) og oppgaver i køen. Hvis ja, tar den en oppgave ut av køen, utfører den og oppdaterer running-telleren.
• finally-blokken sikrer at running-telleren reduseres og at processQueue-metoden kalles igjen for å behandle neste oppgave i køen, selv om oppgaven mislykkes.

Eksempel på bruk

La oss si at du har en liste med URL-er, og du vil hente data fra hver URL ved hjelp av fetch-API-et, men du vil begrense antall samtidige forespørsler for å unngå å overbelaste serveren.

            
async function fetchData(url) {
  console.log(`Henter data fra ${url}`);
  // Simulerer nettverksforsinkelse
  await new Promise(resolve => setTimeout(resolve, Math.random() * 1000));
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`HTTP-feil! 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); // Begrens samtidighet til 3
  const promises = urls.map(url => pool.add(() => fetchData(url)));

  try {
    const results = await Promise.all(promises);
    console.log('Resultater:', results);
  } catch (error) {
    console.error('Feil ved henting av data:', error);
  }
}

main();

            

              
                Copy
              
            
          

I dette eksempelet er PromisePool konfigurert med en samtidighet på 3. urls.map-funksjonen lager en liste med Promises, der hver representerer en oppgave for å hente data fra en spesifikk URL. pool.add-metoden legger til hver oppgave i Promise-poolen, som administrerer utførelsen av disse oppgavene samtidig, og sikrer at ikke mer enn 3 forespørsler er i gang til enhver tid. Promise.all-funksjonen venter på at alle oppgavene skal fullføres og returnerer en liste med resultater.

Rategrensing: Forhindre API-misbruk og tjenesteoverbelastning

Rategrensing er en teknikk for å kontrollere hastigheten som klienter (eller brukere) kan sende forespørsler til en tjeneste eller et API. Det er avgjørende for å forhindre misbruk, beskytte mot tjenestenektangrep (DoS-angrep) og sikre rettferdig ressursbruk. Rategrensing kan implementeres på klientsiden, serversiden eller begge deler.

Hvorfor bruke rategrensing?

• Forhindre misbruk: Begrenser antall forespørsler en enkelt bruker eller klient kan gjøre i en gitt tidsperiode, og forhindrer dem i å overvelde serveren med for mange forespørsler.
• Beskytte mot DoS-angrep: Bidrar til å redusere effekten av distribuerte tjenestenektangrep (DDoS) ved å begrense hastigheten angripere kan sende forespørsler med.
• Sikre rettferdig bruk: Lar forskjellige brukere eller klienter få rettferdig tilgang til ressurser ved å fordele forespørsler jevnt.
• Forbedre ytelsen: Forhindrer at serveren blir overbelastet, og sikrer at den kan svare på forespørsler innen rimelig tid.
• Kostnadsoptimalisering: Reduserer risikoen for å overskride API-brukskvoter og pådra seg ekstra kostnader fra tredjepartstjenester.

Implementering av rategrensing i JavaScript

Det finnes ulike tilnærminger til å implementere rategrensing i JavaScript, hver med sine egne fordeler og ulemper. Her vil vi utforske en klientsideimplementering ved hjelp av en enkel token bucket-algoritme.

            
class RateLimiter {
  constructor(capacity, refillRate, interval) {
    this.capacity = capacity; // Maksimalt antall "tokens"
    this.tokens = capacity;
    this.refillRate = refillRate; // "Tokens" lagt til per intervall
    this.interval = interval; // Intervall i millisekunder

    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('Rategrensen er overskredet.'));
          }
        }, waitTime);
      });
    }
  }
}

            

              
                Copy
              
            
          

Forklaring:

• RateLimiter-klassen tar tre parametere: capacity (maksimalt antall tokens), refillRate (antall tokens som legges til per intervall), og interval (tidsintervallet i millisekunder).
• refill-metoden legger til tokens i "bøtten" med en hastighet på refillRate per interval, opp til maksimal kapasitet.
• consume-metoden prøver å bruke et spesifisert antall tokens (standard er 1). Hvis det er nok tokens tilgjengelig, brukes de, og metoden resolver umiddelbart. Ellers beregner den hvor lang tid man må vente til det er nok tokens tilgjengelig, venter den tiden, og prøver deretter å bruke tokensene igjen. Hvis det fortsatt ikke er nok tokens, avviser den med en feilmelding.

Eksempel på bruk

            
async function makeApiRequest() {
  // Simulerer API-forespørsel
  await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
  console.log('API-forespørsel vellykket');
}

async function main() {
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 forespørsler per sekund

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

main();

            

              
                Copy
              
            
          

I dette eksempelet er RateLimiter konfigurert til å tillate 5 forespørsler per sekund. main-funksjonen gjør 10 API-forespørsler, hvor hver enkelt blir innledet med et kall til rateLimiter.consume(). Hvis rategrensen overskrides, vil consume-metoden avvise med en feil, som fanges opp av try...catch-blokken.

Kombinere Promise-pooler og rategrensing

I noen scenarioer kan det være ønskelig å kombinere Promise-pooler og rategrensing for å oppnå mer finkornet kontroll over samtidighet og forespørselshastigheter. For eksempel kan du ønske å begrense antall samtidige forespørsler til et spesifikt API-endepunkt, samtidig som du sikrer at den totale forespørselshastigheten ikke overstiger en viss terskel.

Slik kan du kombinere disse to mønstrene:

            
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); // Begrens samtidighet til 3
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 forespørsler per sekund

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

  try {
    const results = await Promise.all(promises);
    console.log('Resultater:', results);
  } catch (error) {
    console.error('Feil ved henting av data:', error);
  }
}

main();

            

              
                Copy
              
            
          

I dette eksempelet bruker fetchDataWithRateLimit-funksjonen først en token fra RateLimiter før den henter data fra URL-en. Dette sikrer at forespørselshastigheten begrenses, uavhengig av samtidighetsnivået som styres av PromisePool.

Hensyn for globale applikasjoner

Når du implementerer Promise-pooler og rategrensing i globale applikasjoner, er det viktig å ta hensyn til følgende faktorer:

• Tidssoner: Vær oppmerksom på tidssoner når du implementerer rategrensing. Sørg for at rategrensingslogikken er basert på en konsekvent tidssone eller bruker en tidssone-agnostisk tilnærming (f.eks. UTC).
• Geografisk distribusjon: Hvis applikasjonen din er utplassert i flere geografiske regioner, bør du vurdere å implementere rategrensing per region for å ta høyde for forskjeller i nettverksforsinkelse og brukeratferd. Innholdsleveringsnettverk (CDN-er) tilbyr ofte rategrensingsfunksjoner som kan konfigureres på kanten (edge).
• API-leverandørers rategrenser: Vær klar over rategrensene som er pålagt av tredjeparts-API-er som applikasjonen din bruker. Implementer din egen rategrensingslogikk for å holde deg innenfor disse grensene og unngå å bli blokkert. Vurder å bruke "exponential backoff" med "jitter" for å håndtere rategrensingsfeil på en elegant måte.
• Brukeropplevelse: Gi informative feilmeldinger til brukere når de blir rategrenset, og forklar årsaken til begrensningen og hvordan de kan unngå den i fremtiden. Vurder å tilby forskjellige tjenestenivåer med varierende rategrenser for å imøtekomme ulike brukerbehov.
• Overvåking og logging: Overvåk applikasjonens samtidighet og forespørselshastigheter for å identifisere potensielle flaskehalser og sikre at rategrensingslogikken er effektiv. Logg relevante beregninger for å spore bruksmønstre og identifisere potensielt misbruk.

Konklusjon

Promise-pooler og rategrensing er kraftige verktøy for å håndtere samtidighet og forhindre overbelastning i JavaScript-applikasjoner. Ved å forstå disse mønstrene og implementere dem effektivt, kan du forbedre ytelsen, stabiliteten og skalerbarheten til applikasjonene dine. Enten du bygger en enkel webapplikasjon eller et komplekst distribuert system, er det avgjørende å mestre disse konseptene for å bygge robust og pålitelig programvare.

Husk å vurdere de spesifikke kravene til applikasjonen din nøye og velge den riktige strategien for samtidighetshåndtering. Eksperimenter med forskjellige konfigurasjoner for å finne den optimale balansen mellom ytelse og ressursutnyttelse. Med en solid forståelse av Promise-pooler og rategrensing, vil du være godt rustet til å takle utfordringene i moderne JavaScript-utvikling.