JavaScripti konkurentsuse mustrid: Promise'ide kogumid ja kiirusepiirangud

Tänapäeva JavaScripti arenduses on asünkroonsete operatsioonidega tegelemine põhinõue. Olgu tegemist andmete toomisega API-dest, suurte andmekogumite töötlemisega või kasutaja interaktsioonide haldamisega, on konkurentsuse tõhus haldamine jõudluse ja stabiilsuse seisukohalt ülioluline. Kaks võimsat mustrit, mis selle väljakutse lahendavad, on Promise'ide kogumid ja kiirusepiirangud. See artikkel süveneb nendesse kontseptsioonidesse, pakkudes praktilisi näiteid ja demonstreerides, kuidas neid oma projektides rakendada.

Asünkroonsete operatsioonide ja konkurentsuse mõistmine

JavaScript on oma olemuselt ühelõimeline. See tähendab, et korraga saab täita ainult ühte operatsiooni. Kuid asünkroonsete operatsioonide (kasutades tehnikaid nagu tagasikutsed, Promise'id ja async/await) kasutuselevõtt võimaldab JavaScriptil käsitleda mitut ülesannet samaaegselt ilma peamist lõime blokeerimata. Konkurentsus tähendab selles kontekstis mitme käimasoleva ülesande samaaegset haldamist.

Kaaluge järgmisi stsenaariume:

• Andmete toomine mitmest API-st samaaegselt armatuurlaua täitmiseks.
• Suure hulga piltide töötlemine partiidena.
• Mitme kasutajapäringu käsitlemine, mis nõuavad andmebaasi interaktsioone.

Ilma nõuetekohase konkurentsuse haldamiseta võite kokku puutuda jõudluse kitsaskohtade, suurenenud latentsusaja ja isegi rakenduse ebastabiilsusega. Näiteks API pommitamine liiga paljude päringutega võib põhjustada kiirusepiirangu vigu või isegi teenusekatkestusi. Samamoodi võib liiga paljude protsessorimahukate ülesannete samaaegne käitamine kliendi või serveri ressursid üle koormata.

Promise'ide kogumid: konkurentsete ülesannete haldamine

Promise'ide kogum on mehhanism samaaegsete asünkroonsete operatsioonide arvu piiramiseks. See tagab, et igal ajahetkel töötab ainult teatud arv ülesandeid, vältides ressursside ammendumist ja säilitades reageerimisvõime. See muster on eriti kasulik suure hulga sõltumatute ülesannete puhul, mida saab paralleelselt täita, kuid mida on vaja piirata.

Promise'ide kogumi implementeerimine

Siin on Promise'ide kogumi põhiimplementatsioon JavaScriptis:

            
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(); // Töötle järgmine ülesanne järjekorras
      }
    }
  }
}

            

              
                Copy
              
            
          

Selgitus:

• PromisePool klass võtab parameetri concurrency, mis määrab maksimaalse arvu ülesandeid, mida saab samaaegselt käivitada.
• Meetod add lisab ülesande (funktsioon, mis tagastab Promise'i) järjekorda. See tagastab Promise'i, mis lahendatakse või lükatakse tagasi, kui ülesanne lõpeb.
• Meetod processQueue kontrollib, kas on vabu kohti (this.running < this.concurrency) ja ülesandeid järjekorras. Kui jah, siis võtab see järjekorrast ülesande, täidab selle ja uuendab running loendurit.
• finally plokk tagab, et running loendurit vähendatakse ja processQueue meetod kutsutakse uuesti välja järgmise ülesande töötlemiseks järjekorras, isegi kui ülesanne ebaõnnestub.

Kasutusnäide

Oletame, et teil on URL-ide massiiv ja soovite igast URL-ist andmeid tuua, kasutades fetch API-d, kuid soovite piirata samaaegsete päringute arvu, et vältida serveri ülekoormamist.

            
async function fetchData(url) {
  console.log(`Toon andmeid aadressilt ${url}`);
  // Simuleerime võrgu latentsust
  await new Promise(resolve => setTimeout(resolve, Math.random() * 1000));
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`HTTP viga! staatus: ${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); // Piirame konkurentsuse 3-le
  const promises = urls.map(url => pool.add(() => fetchData(url)));

  try {
    const results = await Promise.all(promises);
    console.log('Tulemused:', results);
  } catch (error) {
    console.error('Viga andmete toomisel:', error);
  }
}

main();

            

              
                Copy
              
            
          

Selles näites on PromisePool konfigureeritud konkurentsusega 3. Funktsioon urls.map loob Promise'ide massiivi, kus igaüks esindab ülesannet andmete toomiseks konkreetsest URL-ist. Meetod pool.add lisab iga ülesande Promise'ide kogumisse, mis haldab nende ülesannete samaaegset täitmist, tagades, et korraga ei ole käimas rohkem kui 3 päringut. Funktsioon Promise.all ootab kõigi ülesannete lõpuleviimist ja tagastab tulemuste massiivi.

Kiirusepiirangud: API väärkasutuse ja teenuse ülekoormuse vältimine

Kiirusepiirang on tehnika, millega kontrollitakse kiirust, millega kliendid (või kasutajad) saavad teenusele või API-le päringuid teha. See on oluline väärkasutuse vältimiseks, teenusetõkestamise (DoS) rünnakute eest kaitsmiseks ja ressursside õiglase kasutamise tagamiseks. Kiirusepiiranguid saab rakendada kliendi poolel, serveri poolel või mõlemal.

Miks kasutada kiirusepiiranguid?

• Väärkasutuse vältimine: Piirab päringute arvu, mida üks kasutaja või klient saab teatud aja jooksul teha, vältides serveri ülekoormamist liigsete päringutega.
• Kaitse DoS-rünnakute eest: Aitab leevendada hajutatud teenusetõkestamise (DDoS) rünnakute mõju, piirates kiirust, millega ründajad saavad päringuid saata.
• Õiglase kasutuse tagamine: Võimaldab erinevatel kasutajatel või klientidel ressurssidele õiglaselt juurde pääseda, jaotades päringuid ühtlaselt.
• Jõudluse parandamine: Hoiab ära serveri ülekoormamise, tagades, et see suudab päringutele õigeaegselt vastata.
• Kulude optimeerimine: Vähendab riski ületada API kasutuslimiite ja kanda lisakulusid kolmandate osapoolte teenuste eest.

Kiirusepiirangute implementeerimine JavaScriptis

JavaScriptis on kiirusepiirangute rakendamiseks erinevaid lähenemisviise, millest igaühel on oma kompromissid. Siin uurime kliendipoolset implementeerimist, kasutades lihtsat "token bucket" (märgikopa) algoritmi.

            
class RateLimiter {
  constructor(capacity, refillRate, interval) {
    this.capacity = capacity; // Märkide maksimaalne arv
    this.tokens = capacity;
    this.refillRate = refillRate; // Märgid, mis lisatakse intervalli kohta
    this.interval = interval; // Intervall millisekundites

    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('Kiirusepiirang ületatud.'));
          }
        }, waitTime);
      });
    }
  }
}

            

              
                Copy
              
            
          

Selgitus:

• Klass RateLimiter võtab kolm parameetrit: capacity (märkide maksimaalne arv), refillRate (intervalli kohta lisatavate märkide arv) ja interval (ajaintervall millisekundites).
• Meetod refill lisab märke "ämbrisse" kiirusega refillRate interval'i kohta, kuni maksimaalse mahutavuseni.
• Meetod consume üritab tarbida määratud arvu märke (vaikimisi 1). Kui saadaval on piisavalt märke, tarbib see need ja lahendab kohe. Vastasel juhul arvutab see ooteaja, kuni piisavalt märke on saadaval, ootab selle aja ja proovib siis uuesti märke tarbida. Kui märke ikka veel piisavalt pole, lükkab see vea tagasi.

Kasutusnäide

            
async function makeApiRequest() {
  // Simuleerime API päringut
  await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
  console.log('API päring õnnestus');
}

async function main() {
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 päringut sekundis

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

main();

            

              
                Copy
              
            
          

Selles näites on RateLimiter konfigureeritud lubama 5 päringut sekundis. Funktsioon main teeb 10 API päringut, millest igaühele eelneb kutse rateLimiter.consume(). Kui kiirusepiirang ületatakse, lükkab meetod consume tagasi vea, mille püüab kinni try...catch plokk.

Promise'ide kogumite ja kiirusepiirangute kombineerimine

Mõnedes stsenaariumides võite soovida kombineerida Promise'ide kogumeid ja kiirusepiiranguid, et saavutada täpsem kontroll konkurentsuse ja päringute kiiruse üle. Näiteks võite soovida piirata samaaegsete päringute arvu konkreetsele API otspunktile, tagades samal ajal, et üldine päringute määr ei ületa teatud läve.

Siin on, kuidas neid kahte mustrit kombineerida:

            
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); // Piirame konkurentsuse 3-le
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 päringut sekundis

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

  try {
    const results = await Promise.all(promises);
    console.log('Tulemused:', results);
  } catch (error) {
    console.error('Viga andmete toomisel:', error);
  }
}

main();

            

              
                Copy
              
            
          

Selles näites tarbib funktsioon fetchDataWithRateLimit esmalt märgi RateLimiter'ist, enne kui toob andmeid URL-ist. See tagab, et päringute kiirus on piiratud, sõltumata PromisePool'i poolt hallatavast konkurentsuse tasemest.

Globaalsete rakenduste kaalutlused

Promise'ide kogumite ja kiirusepiirangute rakendamisel globaalsetes rakendustes on oluline arvestada järgmiste teguritega:

• Ajavööndid: Olge kiirusepiirangute rakendamisel ajavöönditest teadlik. Veenduge, et teie kiirusepiirangu loogika põhineb järjepideval ajavööndil või kasutab ajavööndist sõltumatut lähenemist (nt UTC).
• Geograafiline jaotus: Kui teie rakendus on juurutatud mitmes geograafilises piirkonnas, kaaluge kiirusepiirangute rakendamist piirkonnapõhiselt, et arvestada võrgu latentsuse ja kasutajakäitumise erinevustega. Sisuedastusvõrgud (CDN-id) pakuvad sageli kiirusepiirangu funktsioone, mida saab konfigureerida servas.
• API pakkujate kiiruspiirangud: Olge teadlik kolmandate osapoolte API-de kehtestatud kiiruspiirangutest, mida teie rakendus kasutab. Rakendage oma kiirusepiirangu loogika, et püsida nende piirangute piires ja vältida blokeerimist. Kaaluge eksponentsiaalse ooteaja (exponential backoff with jitter) kasutamist, et kiirusepiirangu vigadega sujuvalt toime tulla.
• Kasutajakogemus: Pakkuge kasutajatele informatiivseid veateateid, kui neile rakendatakse kiirusepiirangut, selgitades piirangu põhjust ja kuidas seda tulevikus vältida. Kaaluge erinevate teenustasemete pakkumist erinevate kiiruspiirangutega, et rahuldada erinevaid kasutajate vajadusi.
• Monitooring ja logimine: Jälgige oma rakenduse konkurentsust ja päringute kiirust, et tuvastada potentsiaalseid kitsaskohti ja tagada, et teie kiirusepiirangu loogika on tõhus. Logige asjakohaseid mõõdikuid, et jälgida kasutusmustreid ja tuvastada võimalikku väärkasutust.

Kokkuvõte

Promise'ide kogumid ja kiirusepiirangud on võimsad tööriistad JavaScripti rakendustes konkurentsuse haldamiseks ja ülekoormuse vältimiseks. Nende mustrite mõistmise ja tõhusa rakendamisega saate parandada oma rakenduste jõudlust, stabiilsust ja skaleeritavust. Ükskõik, kas ehitate lihtsat veebirakendust või keerukat hajutatud süsteemi, on nende kontseptsioonide valdamine vastupidava ja usaldusväärse tarkvara loomisel hädavajalik.

Pidage meeles, et peate hoolikalt kaaluma oma rakenduse spetsiifilisi nõudeid ja valima sobiva konkurentsuse haldamise strateegia. Katsetage erinevate konfiguratsioonidega, et leida optimaalne tasakaal jõudluse ja ressursside kasutamise vahel. Promise'ide kogumite ja kiirusepiirangute põhjaliku mõistmisega olete hästi varustatud, et tulla toime tänapäeva JavaScripti arenduse väljakutsetega.