JavaScript Asinhronā Iteratora Palīga Resursu Kopa: Asinhrono Plūsmu Resursu Pārvaldība

Asinhronā programmēšana ir mūsdienu JavaScript izstrādes pamats, īpaši strādājot ar I/O saistītām operācijām, piemēram, tīkla pieprasījumiem, failu sistēmas piekļuvi un datu bāzes vaicājumiem. Asinhronie iteratori, kas ieviesti ES2018, nodrošina jaudīgu mehānismu asinhronu datu plūsmu patērēšanai. Tomēr efektīva asinhrono resursu pārvaldība šajās plūsmās var būt izaicinājums. Šajā rakstā aplūkots, kā izveidot stabilu resursu kopu, izmantojot asinhronos iteratorus un palīgfunkcijas, lai optimizētu veiktspēju un novērstu resursu izsīkumu.

Izpratne par asinhronajiem iteratoriem

Asinhronais iterators ir objekts, kas atbilst asinhronā iteratora protokolam. Tas definē `next()` metodi, kas atgriež solījumu (promise), kurš atrisinās par objektu ar divām īpašībām: `value` un `done`. `value` īpašība satur nākamo elementu secībā, un `done` ir Būla vērtība, kas norāda, vai iterators ir sasniedzis secības beigas. Atšķirībā no parastajiem iteratoriem, katrs `next()` izsaukums var būt asinhronisks, ļaujot apstrādāt datus nebloķējošā veidā.

Šeit ir vienkāršs piemērs asinhronam iteratoram, kas ģenerē skaitļu secību:

            
async function* numberGenerator(max) {
  for (let i = 0; i <= max; i++) {
    await delay(100); // Simulate asynchronous operation
    yield i;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

(async () => {
  for await (const number of numberGenerator(5)) {
    console.log(number);
  }
})();

            

              
                Copy
              
            
          

Šajā piemērā `numberGenerator` ir asinhronā ģeneratora funkcija. `yield` atslēgvārds aptur ģeneratora funkcijas izpildi un atgriež solījumu, kas atrisinās ar atgriezto vērtību. `for await...of` cikls iterē pāri vērtībām, ko ražo asinhronais iterators.

Nepieciešamība pēc resursu pārvaldības

Strādājot ar asinhronām plūsmām, ir būtiski efektīvi pārvaldīt resursus. Apsveriet scenāriju, kurā jūs apstrādājat lielu failu, veicat daudzus API izsaukumus vai mijiedarbojaties ar datu bāzi. Bez pienācīgas resursu pārvaldības jūs varētu viegli izsmelt sistēmas resursus, kas novestu pie veiktspējas pasliktināšanās, kļūdām vai pat lietojumprogrammas avārijas.

Šeit ir daži izplatīti resursu pārvaldības izaicinājumi asinhronās plūsmās:

• Vienlaicīguma limiti: Pārāk daudz vienlaicīgu pieprasījumu veikšana var pārslogot serverus vai datu bāzes.
• Resursu noplūdes: Nespēja atbrīvot resursus (piem., failu identifikatorus, datu bāzes savienojumus) var novest pie resursu izsīkuma.
• Kļūdu apstrāde: Ir būtiski graciozi apstrādāt kļūdas un nodrošināt resursu atbrīvošanu pat tad, ja rodas kļūdas.

Iepazīstinām ar asinhronā iteratora palīga resursu kopu

Asinhronā iteratora palīga resursu kopa nodrošina mehānismu, lai pārvaldītu ierobežotu skaitu resursu, kurus var koplietot starp vairākām asinhronām operācijām. Tā palīdz kontrolēt vienlaicīgumu, novērst resursu izsīkumu un uzlabot kopējo lietojumprogrammas veiktspēju. Pamatideja ir iegūt resursu no kopas pirms asinhronas operācijas uzsākšanas un atbrīvot to atpakaļ kopā, kad operācija ir pabeigta.

Resursu kopas pamatkomponenti

1. Resursu izveide: Funkcija, kas izveido jaunu resursu (piem., datu bāzes savienojumu, API klientu).
2. Resursu iznīcināšana: Funkcija, kas iznīcina resursu (piem., aizver datu bāzes savienojumu, atbrīvo API klientu).
3. Iegūšana: Metode, lai iegūtu brīvu resursu no kopas. Ja nav pieejamu resursu, tā gaida, līdz resurss kļūst pieejams.
4. Atbrīvošana: Metode, lai atbrīvotu resursu atpakaļ kopā, padarot to pieejamu citām operācijām.
5. Kopas izmērs: Maksimālais resursu skaits, ko kopa var pārvaldīt.

Implementācijas piemērs

Šeit ir piemērs asinhronā iteratora palīga resursu kopas implementācijai JavaScript:

            
class ResourcePool {
  constructor(resourceFactory, resourceDestroyer, poolSize) {
    this.resourceFactory = resourceFactory;
    this.resourceDestroyer = resourceDestroyer;
    this.poolSize = poolSize;
    this.availableResources = [];
    this.acquiredResources = new Set();
    this.waitingQueue = [];

    // Pre-populate the pool with initial resources
    for (let i = 0; i < poolSize; i++) {
      this.availableResources.push(resourceFactory());
    }
  }

  async acquire() {
    if (this.availableResources.length > 0) {
      const resource = this.availableResources.pop();
      this.acquiredResources.add(resource);
      return resource;
    } else {
      return new Promise(resolve => {
        this.waitingQueue.push(resolve);
      });
    }
  }

  release(resource) {
    if (this.acquiredResources.has(resource)) {
      this.acquiredResources.delete(resource);
      this.availableResources.push(resource);

      if (this.waitingQueue.length > 0) {
        const resolve = this.waitingQueue.shift();
        resolve(this.availableResources.pop());
      }
    } else {
      console.warn("Releasing a resource that wasn't acquired from this pool.");
    }
  }

  async destroy() {
    for (const resource of this.availableResources) {
      await this.resourceDestroyer(resource);
    }
    this.availableResources = [];

    for (const resource of this.acquiredResources) {
      await this.resourceDestroyer(resource);
    }
    this.acquiredResources.clear();
  }
}

// Example usage with a hypothetical database connection
async function createDatabaseConnection() {
  // Simulate creating a database connection
  await delay(50);
  return { id: Math.random(), status: 'connected' };
}

async function closeDatabaseConnection(connection) {
  // Simulate closing a database connection
  await delay(50);
  console.log(`Closing connection ${connection.id}`);
}

(async () => {
  const poolSize = 5;
  const dbPool = new ResourcePool(createDatabaseConnection, closeDatabaseConnection, poolSize);

  async function processData(data) {
    const connection = await dbPool.acquire();
    console.log(`Processing data ${data} with connection ${connection.id}`);
    await delay(100); // Simulate database operation
    dbPool.release(connection);
  }

  const dataToProcess = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  const promises = dataToProcess.map(data => processData(data));
  await Promise.all(promises);

  await dbPool.destroy();
})();

            

              
                Copy
              
            
          

Šajā piemērā:

• `ResourcePool` ir klase, kas pārvalda resursu kopu.
• `resourceFactory` ir funkcija, kas izveido jaunu datu bāzes savienojumu.
• `resourceDestroyer` ir funkcija, kas aizver datu bāzes savienojumu.
• `acquire()` iegūst savienojumu no kopas.
• `release()` atbrīvo savienojumu atpakaļ kopā.
• `destroy()` iznīcina visus resursus kopā.

Integrācija ar asinhronajiem iteratoriem

Jūs varat nevainojami integrēt resursu kopu ar asinhronajiem iteratoriem, lai apstrādātu datu plūsmas, vienlaikus efektīvi pārvaldot resursus. Šeit ir piemērs:

            
async function* processStream(dataStream, resourcePool) {
  for await (const data of dataStream) {
    const resource = await resourcePool.acquire();
    try {
      // Process the data using the acquired resource
      const result = await processData(data, resource);
      yield result;
    } finally {
      resourcePool.release(resource);
    }
  }
}

async function processData(data, resource) {
  // Simulate processing data with the resource
  await delay(50);
  return `Processed ${data} with resource ${resource.id}`;
}

(async () => {
    const poolSize = 3;
    const dbPool = new ResourcePool(createDatabaseConnection, closeDatabaseConnection, poolSize);

    async function* generateData() {
        for (let i = 1; i <= 10; i++) {
            await delay(20);
            yield i;
        }
    }

    const dataStream = generateData();
    const results = [];
    for await (const result of processStream(dataStream, dbPool)) {
        results.push(result);
        console.log(result);
    }

    await dbPool.destroy();
})();

            

              
                Copy
              
            
          

Šajā piemērā `processStream` ir asinhrona ģeneratora funkcija, kas patērē datu plūsmu un apstrādā katru elementu, izmantojot resursu, kas iegūts no resursu kopas. `try...finally` bloks nodrošina, ka resurss vienmēr tiek atbrīvots atpakaļ kopā, pat ja apstrādes laikā rodas kļūda.

Resursu kopas izmantošanas priekšrocības

• Uzlabota veiktspēja: Atkārtoti izmantojot resursus, jūs varat izvairīties no resursu izveides un iznīcināšanas papildu izmaksām katrai operācijai.
• Kontrolēts vienlaicīgums: Resursu kopa ierobežo vienlaicīgo operāciju skaitu, novēršot resursu izsīkumu un uzlabojot sistēmas stabilitāti.
• Vienkāršota resursu pārvaldība: Resursu kopa ietver resursu iegūšanas un atbrīvošanas loģiku, atvieglojot resursu pārvaldību jūsu lietojumprogrammā.
• Uzlabota kļūdu apstrāde: Resursu kopa var palīdzēt nodrošināt, ka resursi tiek atbrīvoti pat tad, ja rodas kļūdas, novēršot resursu noplūdes.

Papildu apsvērumi

Resursu validācija

Ir būtiski validēt resursus pirms to izmantošanas, lai nodrošinātu, ka tie joprojām ir derīgi. Piemēram, jūs varētu vēlēties pārbaudīt, vai datu bāzes savienojums joprojām ir aktīvs pirms tā izmantošanas. Ja resurss ir nederīgs, jūs varat to iznīcināt un iegūt jaunu no kopas.

            
class ResourcePool {
  // ... (previous code) ...

  async acquire() {
    while (true) {
      if (this.availableResources.length > 0) {
        const resource = this.availableResources.pop();
        if (await this.isValidResource(resource)) {
          this.acquiredResources.add(resource);
          return resource;
        } else {
          console.warn("Invalid resource detected, destroying and acquiring a new one.");
          await this.resourceDestroyer(resource);
          // Attempt to acquire another resource (loop continues)
        }
      } else {
        return new Promise(resolve => {
          this.waitingQueue.push(resolve);
        });
      }
    }
  }

  async isValidResource(resource) {
    // Implement your resource validation logic here
    // For example, check if a database connection is still active
    try {
        // Simulate a check
        await delay(10);
        return true; // Assume valid for this example
    } catch (error) {
        console.error("Resource is invalid:", error);
        return false;
    }
  }

  // ... (rest of the code) ...
}

            

              
                Copy
              
            
          

Resursa noilgums

Jūs varētu vēlēties ieviest noilguma mehānismu, lai novērstu, ka operācijas gaida resursu bezgalīgi ilgi. Ja operācija pārsniedz noilgumu, jūs varat noraidīt solījumu un atbilstoši apstrādāt kļūdu.

            
class ResourcePool {
    // ... (previous code) ...

    async acquire(timeout = 5000) { // Default timeout of 5 seconds
        return new Promise((resolve, reject) => {
            let timeoutId;

            const acquireResource = () => {
                if (this.availableResources.length > 0) {
                    const resource = this.availableResources.pop();
                    this.acquiredResources.add(resource);
                    clearTimeout(timeoutId);
                    resolve(resource);
                } else {
                    // Resource not immediately available, try again after a short delay
                    setTimeout(acquireResource, 50);
                }
            };

            timeoutId = setTimeout(() => {
                reject(new Error("Timeout acquiring resource from pool."));
            }, timeout);

            acquireResource(); // Start trying to acquire immediately
        });
    }

    // ... (rest of the code) ...
}

(async () => {
    const poolSize = 2;
    const dbPool = new ResourcePool(createDatabaseConnection, closeDatabaseConnection, poolSize);

    try {
        const connection = await dbPool.acquire(2000); // Acquire with a 2-second timeout
        console.log("Acquired connection:", connection.id);
        dbPool.release(connection);
    } catch (error) {
        console.error("Error acquiring connection:", error.message);
    }

    await dbPool.destroy();
})();

            

              
                Copy
              
            
          

Monitorings un metrika

Ieviesiet monitoringu un metriku, lai sekotu līdzi resursu kopas izmantošanai. Tas var palīdzēt jums identificēt vājās vietas un optimizēt kopas izmēru un resursu sadalījumu.

• Pieejamo resursu skaits.
• Iegūto resursu skaits.
• Gaidošo pieprasījumu skaits.
• Vidējais iegūšanas laiks.

Reālās pasaules lietošanas gadījumi

• Datu bāzes savienojumu apvienošana (Pooling): Pārvaldot datu bāzes savienojumu kopu, lai apstrādātu vienlaicīgus vaicājumus. Tas ir izplatīti lietojumprogrammās, kas intensīvi mijiedarbojas ar datu bāzēm, piemēram, e-komercijas platformās vai satura pārvaldības sistēmās. Piemēram, globālai e-komercijas vietnei var būt dažādas datu bāzes kopas dažādiem reģioniem, lai optimizētu latentumu.
• API pieprasījumu ātruma ierobežošana: Kontrolējot uz ārējiem API veikto pieprasījumu skaitu, lai izvairītos no ātruma ierobežojumu pārsniegšanas. Daudzi API, īpaši tie, kas nāk no sociālo mediju platformām vai mākoņpakalpojumiem, nosaka ātruma ierobežojumus, lai novērstu ļaunprātīgu izmantošanu. Resursu kopu var izmantot, lai pārvaldītu pieejamos API žetonus vai savienojuma slotus. Iedomājieties ceļojumu rezervēšanas vietni, kas integrējas ar vairākiem aviosabiedrību API; resursu kopa palīdz pārvaldīt vienlaicīgus API izsaukumus.
• Failu apstrāde: Ierobežojot vienlaicīgu failu lasīšanas/rakstīšanas operāciju skaitu, lai novērstu diska I/O sastrēgumus. Tas ir īpaši svarīgi, apstrādājot lielus failus vai strādājot ar uzglabāšanas sistēmām, kurām ir vienlaicīguma ierobežojumi. Piemēram, mediju pārkodēšanas pakalpojums varētu izmantot resursu kopu, lai ierobežotu vienlaicīgu video kodēšanas procesu skaitu.
• Web Socket savienojumu pārvaldība: Pārvaldot websocket savienojumu kopu ar dažādiem serveriem vai pakalpojumiem. Resursu kopa var ierobežot jebkurā laikā atvērto savienojumu skaitu, lai uzlabotu veiktspēju un uzticamību. Piemērs: tērzēšanas serveris vai reāllaika tirdzniecības platforma.

Alternatīvas resursu kopām

Lai gan resursu kopas ir efektīvas, pastāv arī citas pieejas vienlaicīguma un resursu lietojuma pārvaldībai:

• Rindas (Queues): Izmantojiet ziņojumu rindu, lai atsaistītu ražotājus un patērētājus, ļaujot jums kontrolēt ziņojumu apstrādes ātrumu. Ziņojumu rindas, piemēram, RabbitMQ vai Kafka, tiek plaši izmantotas asinhronai uzdevumu apstrādei.
• Semafori: Semafors ir sinhronizācijas primitīvs, ko var izmantot, lai ierobežotu vienlaicīgu piekļuvju skaitu koplietojamam resursam.
• Vienlaicīguma bibliotēkas: Bibliotēkas, piemēram, `p-limit`, nodrošina vienkāršus API, lai ierobežotu vienlaicīgumu asinhronās operācijās.

Pieejas izvēle ir atkarīga no jūsu lietojumprogrammas specifiskajām prasībām.

Noslēgums

Asinhronie iteratori un palīgfunkcijas apvienojumā ar resursu kopu nodrošina jaudīgu un elastīgu veidu, kā pārvaldīt asinhronos resursus JavaScript. Kontrolējot vienlaicīgumu, novēršot resursu izsīkumu un vienkāršojot resursu pārvaldību, jūs varat veidot stabilākas un veiktspējīgākas lietojumprogrammas. Apsveriet resursu kopas izmantošanu, strādājot ar I/O saistītām operācijām, kas prasa efektīvu resursu izmantošanu. Atcerieties validēt savus resursus, ieviest noilguma mehānismus un uzraudzīt resursu kopas lietojumu, lai nodrošinātu optimālu veiktspēju. Izprotot un pielietojot šos principus, jūs varat veidot mērogojamākas un uzticamākas asinhronas lietojumprogrammas, kas spēj apmierināt mūsdienu tīmekļa izstrādes prasības.