JavaScriptin rinnakkaisuusmallit: Promise-poolit ja nopeusrajoitukset

Nykyaikaisessa JavaScript-kehityksessä asynkronisten operaatioiden käsittely on perusvaatimus. Olipa kyseessä datan noutaminen API-rajapinnoista, suurten tietomäärien käsittely tai käyttäjäinteraktioiden hallinta, rinnakkaisuuden tehokas hallinta on ratkaisevan tärkeää suorituskyvyn ja vakauden kannalta. Kaksi tehokasta mallia, jotka vastaavat tähän haasteeseen, ovat Promise-poolit ja nopeusrajoitukset. Tässä artikkelissa syvennytään näihin käsitteisiin, tarjotaan käytännön esimerkkejä ja osoitetaan, kuinka niitä voidaan toteuttaa omissa projekteissa.

Asynkronisten operaatioiden ja rinnakkaisuuden ymmärtäminen

JavaScript on luonteeltaan yksisäikeinen. Tämä tarkoittaa, että vain yksi operaatio voi suorittua kerrallaan. Kuitenkin, asynkronisten operaatioiden (käyttäen tekniikoita kuten takaisinkutsut, Promiset ja async/await) käyttöönotto mahdollistaa JavaScriptin käsitellä useita tehtäviä rinnakkain estämättä pääsäiettä. Rinnakkaisuus, tässä yhteydessä, tarkoittaa useiden samanaikaisesti käynnissä olevien tehtävien hallintaa.

Harkitse näitä skenaarioita:

• Datan noutaminen useista API-rajapinnoista samanaikaisesti kojelaudan täyttämiseksi.
• Suuren määrän kuvia käsittely eräajona.
• Useiden käyttäjäpyyntöjen käsittely, jotka vaativat tietokantatoimintoja.

Ilman asianmukaista rinnakkaisuuden hallintaa saatat kohdata suorituskyvyn pullonkauloja, lisääntynyttä viivettä ja jopa sovelluksen epävakautta. Esimerkiksi API:n pommittaminen liian monilla pyynnöillä voi johtaa nopeusrajoitusvirheisiin tai jopa palvelukatkoihin. Vastaavasti liian monien CPU-intensiivisten tehtävien suorittaminen rinnakkain voi ylikuormittaa asiakkaan tai palvelimen resursseja.

Promise-poolit: Rinnakkaisten tehtävien hallinta

Promise-pooli on mekanismi, jolla rajoitetaan samanaikaisesti suoritettavien asynkronisten operaatioiden määrää. Se varmistaa, että vain tietty määrä tehtäviä on käynnissä kerrallaan, mikä estää resurssien ehtymisen ja ylläpitää sovelluksen responsiivisuutta. Tämä malli on erityisen hyödyllinen, kun käsitellään suurta määrää itsenäisiä tehtäviä, jotka voidaan suorittaa rinnakkain, mutta joita on rajoitettava.

Promise-poolin toteuttaminen

Tässä on perusimplementaatio Promise-poolista JavaScriptillä:

            
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(); // Käsittele seuraava tehtävä jonossa
      }
    }
  }
}

            

              
                Copy
              
            
          

Selitys:

• PromisePool-luokka ottaa concurrency-parametrin, joka määrittää samanaikaisesti suoritettavien tehtävien enimmäismäärän.
• add-metodi lisää tehtävän (funktion, joka palauttaa Promisen) jonoon. Se palauttaa Promisen, joka ratkeaa tai hylätään, kun tehtävä on valmis.
• processQueue-metodi tarkistaa, onko vapaita paikkoja (this.running < this.concurrency) ja tehtäviä jonossa. Jos on, se poistaa tehtävän jonosta, suorittaa sen ja päivittää running-laskurin.
• finally-lohko varmistaa, että running-laskuria vähennetään ja processQueue-metodia kutsutaan uudelleen seuraavan tehtävän käsittelemiseksi jonossa, vaikka tehtävä epäonnistuisi.

Käyttöesimerkki

Oletetaan, että sinulla on joukko URL-osoitteita ja haluat noutaa dataa jokaisesta osoitteesta käyttämällä fetch-API:a, mutta haluat rajoittaa samanaikaisten pyyntöjen määrää palvelimen ylikuormittumisen välttämiseksi.

            
async function fetchData(url) {
  console.log(`Fetching data from ${url}`);
  // Simuloi verkon viivettä
  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); // Rajoita rinnakkaisuus kolmeen
  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
              
            
          

Tässä esimerkissä PromisePool on määritetty rinnakkaisuudella 3. urls.map-funktio luo joukon Promiseja, joista kukin edustaa tehtävää noutaa dataa tietystä URL-osoitteesta. pool.add-metodi lisää kunkin tehtävän Promise-pooliin, joka hallinnoi näiden tehtävien suoritusta rinnakkain, varmistaen että enintään 3 pyyntöä on käynnissä kerrallaan. Promise.all-funktio odottaa kaikkien tehtävien valmistumista ja palauttaa tulokset taulukkona.

Nopeusrajoitus: API:n väärinkäytön ja palvelun ylikuormituksen estäminen

Nopeusrajoitus on tekniikka, jolla hallitaan nopeutta, jolla asiakkaat (tai käyttäjät) voivat tehdä pyyntöjä palveluun tai API-rajapintaan. Se on välttämätöntä väärinkäytön estämisessä, palvelunestohyökkäyksiltä (DoS) suojautumisessa ja resurssien oikeudenmukaisen käytön varmistamisessa. Nopeusrajoitus voidaan toteuttaa asiakaspuolella, palvelinpuolella tai molemmissa.

Miksi käyttää nopeusrajoitusta?

• Väärinkäytön estäminen: Rajoittaa pyyntöjen määrää, jonka yksittäinen käyttäjä tai asiakas voi tehdä tietyssä ajassa, estäen heitä ylikuormittamasta palvelinta liiallisilla pyynnöillä.
• Suojautuminen DoS-hyökkäyksiltä: Auttaa lieventämään hajautettujen palvelunestohyökkäysten (DDoS) vaikutusta rajoittamalla nopeutta, jolla hyökkääjät voivat lähettää pyyntöjä.
• Oikeudenmukaisen käytön varmistaminen: Mahdollistaa eri käyttäjille tai asiakkaille resurssien tasapuolisen käytön jakamalla pyynnöt tasaisesti.
• Suorituskyvyn parantaminen: Estää palvelimen ylikuormittumisen ja varmistaa, että se voi vastata pyyntöihin ajoissa.
• Kustannusten optimointi: Vähentää riskiä ylittää API-käyttökiintiöt ja aiheuttaa lisäkustannuksia kolmansien osapuolien palveluista.

Nopeusrajoituksen toteuttaminen JavaScriptissä

JavaScriptissä on erilaisia tapoja toteuttaa nopeusrajoitus, joilla kullakin on omat kompromissinsa. Tässä tutkimme asiakaspuolen toteutusta käyttäen yksinkertaista token bucket -algoritmia.

            
class RateLimiter {
  constructor(capacity, refillRate, interval) {
    this.capacity = capacity; // Tokenien enimmäismäärä
    this.tokens = capacity;
    this.refillRate = refillRate; // Lisätyt tokenit per aikaväli
    this.interval = interval; // Aikaväli millisekunteina

    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
              
            
          

Selitys:

• RateLimiter-luokka ottaa kolme parametria: capacity (tokenien enimmäismäärä), refillRate (aikavälillä lisättävien tokenien määrä) ja interval (aikaväli millisekunteina).
• refill-metodi lisää tokeneita säiliöön nopeudella refillRate per interval, enimmäiskapasiteettiin asti.
• consume-metodi yrittää kuluttaa tietyn määrän tokeneita (oletuksena 1). Jos tokeneita on tarpeeksi saatavilla, se kuluttaa ne ja ratkeaa välittömästi. Muussa tapauksessa se laskee odotusajan, kunnes tokeneita on riittävästi, odottaa sen ajan ja yrittää sitten kuluttaa tokenit uudelleen. Jos tokeneita ei vieläkään ole tarpeeksi, se hylätään virheellä.

Käyttöesimerkki

            
async function makeApiRequest() {
  // Simuloi API-pyyntöä
  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 pyyntöä sekunnissa

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

main();

            

              
                Copy
              
            
          

Tässä esimerkissä RateLimiter on määritetty sallimaan 5 pyyntöä sekunnissa. main-funktio tekee 10 API-pyyntöä, joista jokaista edeltää kutsu rateLimiter.consume()-metodiin. Jos nopeusrajoitus ylittyy, consume-metodi hylätään virheellä, joka otetaan kiinni try...catch-lohkossa.

Promise-poolien ja nopeusrajoitusten yhdistäminen

Joissakin skenaarioissa saatat haluta yhdistää Promise-poolit ja nopeusrajoitukset saavuttaaksesi tarkemman hallinnan rinnakkaisuudesta ja pyyntönopeuksista. Voit esimerkiksi haluta rajoittaa samanaikaisten pyyntöjen määrää tiettyyn API-päätepisteeseen ja samalla varmistaa, että kokonaispyyntönopeus ei ylitä tiettyä kynnysarvoa.

Näin voit yhdistää nämä kaksi mallia:

            
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); // Rajoita rinnakkaisuus kolmeen
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 pyyntöä sekunnissa

  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
              
            
          

Tässä esimerkissä fetchDataWithRateLimit-funktio kuluttaa ensin tokenin RateLimiter-oliosta ennen datan noutamista URL-osoitteesta. Tämä varmistaa, että pyyntönopeus on rajoitettu, riippumatta PromisePool-olion hallinnoimasta rinnakkaisuustasosta.

Huomioitavaa globaaleissa sovelluksissa

Kun toteutat Promise-pooleja ja nopeusrajoituksia globaaleissa sovelluksissa, on tärkeää ottaa huomioon seuraavat tekijät:

• Aikavyöhykkeet: Ole tietoinen aikavyöhykkeistä, kun toteutat nopeusrajoitusta. Varmista, että nopeusrajoituslogiikkasi perustuu yhtenäiseen aikavyöhykkeeseen tai käyttää aikavyöhykkeestä riippumatonta lähestymistapaa (esim. UTC).
• Maantieteellinen jakautuminen: Jos sovelluksesi on käytössä useilla maantieteellisillä alueilla, harkitse nopeusrajoituksen toteuttamista aluekohtaisesti ottaen huomioon erot verkon viiveessä ja käyttäjäkäyttäytymisessä. Sisällönjakeluverkot (CDN) tarjoavat usein nopeusrajoitusominaisuuksia, jotka voidaan konfiguroida verkon reunalla.
• API-tarjoajien nopeusrajoitukset: Ole tietoinen kolmansien osapuolien API-rajapintojen asettamista nopeusrajoituksista, joita sovelluksesi käyttää. Toteuta oma nopeusrajoituslogiikkasi pysyäksesi näiden rajojen sisällä ja välttääksesi estetyksi tulemisen. Harkitse eksponentiaalisen viiveen (exponential backoff) käyttöä "jitterillä" käsitelläksesi nopeusrajoitusvirheet sulavasti.
• Käyttäjäkokemus: Tarjoa informatiivisia virheilmoituksia käyttäjille, kun heitä nopeusrajoitetaan, selittäen rajoituksen syyn ja kuinka sen voi välttää tulevaisuudessa. Harkitse eritasoisten palvelupakettien tarjoamista vaihtelevilla nopeusrajoituksilla eri käyttäjätarpeiden mukaan.
• Seuranta ja lokitus: Seuraa sovelluksesi rinnakkaisuutta ja pyyntönopeuksia tunnistaaksesi mahdolliset pullonkaulat ja varmistaaksesi, että nopeusrajoituslogiikkasi on tehokas. Tallenna asiaankuuluvat mittarit lokiin käyttöasteen seuraamiseksi ja mahdollisen väärinkäytön tunnistamiseksi.

Yhteenveto

Promise-poolit ja nopeusrajoitukset ovat tehokkaita työkaluja rinnakkaisuuden hallintaan ja ylikuormituksen estämiseen JavaScript-sovelluksissa. Ymmärtämällä nämä mallit ja toteuttamalla ne tehokkaasti, voit parantaa sovellustesi suorituskykyä, vakautta ja skaalautuvuutta. Rakennatpa sitten yksinkertaista verkkosovellusta tai monimutkaista hajautettua järjestelmää, näiden käsitteiden hallitseminen on välttämätöntä vankkojen ja luotettavien ohjelmistojen rakentamisessa.

Muista harkita huolellisesti sovelluksesi erityisvaatimuksia ja valita sopiva rinnakkaisuuden hallintastrategia. Kokeile erilaisia konfiguraatioita löytääksesi optimaalisen tasapainon suorituskyvyn ja resurssien käytön välillä. Vahvalla ymmärryksellä Promise-pooleista ja nopeusrajoituksista olet hyvin varustautunut vastaamaan nykyaikaisen JavaScript-kehityksen haasteisiin.