JavaScript Asinxron Iterator Yordamchi Resurslar Puli: Asinxron Oqim Resurslarini Boshqarish

Asinxron dasturlash zamonaviy JavaScript ishlab chiqishning asosidir, ayniqsa tarmoq so'rovlari, fayl tizimiga kirish va ma'lumotlar bazasi so'rovlari kabi I/O bilan bog'liq operatsiyalarda. ES2018 da taqdim etilgan asinxron iteratorlar asinxron ma'lumotlar oqimlarini iste'mol qilish uchun kuchli mexanizmni ta'minlaydi. Biroq, ushbu oqimlar ichida asinxron resurslarni samarali boshqarish qiyin bo'lishi mumkin. Ushbu maqolada unumdorlikni optimallashtirish va resurslarning tugab qolishining oldini olish uchun asinxron iteratorlar va yordamchi funksiyalar yordamida mustahkam resurslar pulini qanday yaratish mumkinligi ko'rib chiqiladi.

Asinxron Iteratorlarni Tushunish

Asinxron iterator — bu asinxron iterator protokoliga mos keladigan obyekt. U ikkita xususiyatga ega bo'lgan obyektga aylanadigan promise qaytaruvchi `next()` metodini belgilaydi: `value` va `done`. `value` xususiyati ketma-ketlikdagi keyingi elementni saqlaydi, `done` xususiyati esa iterator ketma-ketlikning oxiriga yetganligini ko'rsatuvchi mantiqiy qiymatdir. Oddiy iteratorlardan farqli o'laroq, `next()` ga har bir chaqiruv asinxron bo'lishi mumkin, bu sizga ma'lumotlarni bloklanmaydigan tarzda qayta ishlash imkonini beradi.

Bu yerda raqamlar ketma-ketligini generatsiya qiluvchi asinxron iteratorning oddiy misoli keltirilgan:

            
async function* numberGenerator(max) {
  for (let i = 0; i <= max; i++) {
    await delay(100); // Asinxron operatsiyani simulyatsiya qilish
    yield i;
  }
}

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

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

            

              
                Copy
              
            
          

Ushbu misolda `numberGenerator` asinxron generator funksiyasidir. `yield` kalit so'zi generator funksiyasining bajarilishini to'xtatib turadi va berilgan qiymat bilan yakunlanadigan promise qaytaradi. `for await...of` tsikli asinxron iterator tomonidan ishlab chiqarilgan qiymatlar bo'yicha iteratsiya qiladi.

Resurslarni Boshqarishga bo'lgan Ehtiyoj

Asinxron oqimlar bilan ishlaganda resurslarni samarali boshqarish juda muhim. Katta faylni qayta ishlash, ko'plab API chaqiruvlarini amalga oshirish yoki ma'lumotlar bazasi bilan o'zaro aloqada bo'lish stsenariysini ko'rib chiqing. To'g'ri resurs boshqaruvisiz siz tizim resurslarini osongina tugatib qo'yishingiz mumkin, bu esa unumdorlikning pasayishiga, xatolarga yoki hatto dasturning ishdan chiqishiga olib keladi.

Asinxron oqimlarda resurslarni boshqarishning ba'zi umumiy muammolari:

• Konkurentlik Cheklovlari: Juda ko'p bir vaqtda so'rovlar yuborish serverlar yoki ma'lumotlar bazalarini haddan tashqari yuklashi mumkin.
• Resurs Sızıntıları: Resurslarni (masalan, fayl dastaklari, ma'lumotlar bazasi ulanishlari) bo'shatmaslik resurslarning tugashiga olib kelishi mumkin.
• Xatolarni Qayta Ishlash: Xatolarni to'g'ri qayta ishlash va xatolar yuz berganda ham resurslarning bo'shatilishini ta'minlash muhimdir.

Asinxron Iterator Yordamchi Resurslar Puli bilan Tanishtirish

Asinxron iterator yordamchi resurslar puli bir nechta asinxron operatsiyalar o'rtasida taqsimlanishi mumkin bo'lgan cheklangan miqdordagi resurslarni boshqarish uchun mexanizmni ta'minlaydi. U konkurentlikni nazorat qilish, resurslarning tugab qolishining oldini olish va umumiy dastur unumdorligini oshirishga yordam beradi. Asosiy g'oya — asinxron operatsiyani boshlashdan oldin puldan resurs olish va operatsiya tugagach uni pulga qaytarishdir.

Resurslar Pulining Asosiy Komponentlari

1. Resurs Yaratish: Yangi resurs yaratadigan funksiya (masalan, ma'lumotlar bazasi ulanishi, API mijozi).
2. Resursni Yo'q qilish: Resursni yo'q qiladigan funksiya (masalan, ma'lumotlar bazasi ulanishini yopish, API mijozini bo'shatish).
3. Olish: Puldan bo'sh resurs olish usuli. Agar mavjud resurslar bo'lmasa, u resurs paydo bo'lguncha kutadi.
4. Bo'shatish: Resursni pulga qaytarish usuli, uni boshqa operatsiyalar uchun mavjud qilib qo'yadi.
5. Pul Hajmi: Pul boshqarishi mumkin bo'lgan resurslarning maksimal soni.

Amalga Oshirish Misoli

Bu yerda JavaScript-da asinxron iterator yordamchi resurslar pulini amalga oshirish misoli keltirilgan:

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

    // Pulni boshlang'ich resurslar bilan oldindan to'ldirish
    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("Ushbu puldan olinmagan resurs bo'shatilmoqda.");
    }
  }

  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();
  }
}

// Faraziy ma'lumotlar bazasi ulanishi bilan foydalanish misoli
async function createDatabaseConnection() {
  // Ma'lumotlar bazasi ulanishini yaratishni simulyatsiya qilish
  await delay(50);
  return { id: Math.random(), status: 'connected' };
}

async function closeDatabaseConnection(connection) {
  // Ma'lumotlar bazasi ulanishini yopishni simulyatsiya qilish
  await delay(50);
  console.log(`${connection.id} ulanishi yopilmoqda`);
}

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

  async function processData(data) {
    const connection = await dbPool.acquire();
    console.log(`${data} ma'lumoti ${connection.id} ulanishi bilan qayta ishlanmoqda`);
    await delay(100); // Ma'lumotlar bazasi operatsiyasini simulyatsiya qilish
    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
              
            
          

Ushbu misolda:

• `ResourcePool` — bu resurslar pulini boshqaradigan sinf.
• `resourceFactory` — yangi ma'lumotlar bazasi ulanishini yaratadigan funksiya.
• `resourceDestroyer` — ma'lumotlar bazasi ulanishini yopadigan funksiya.
• `acquire()` puldan ulanishni oladi.
• `release()` ulanishni pulga qaytaradi.
• `destroy()` puldagi barcha resurslarni yo'q qiladi.

Asinxron Iteratorlar bilan Integratsiya

Siz resurslar pulini asinxron iteratorlar bilan uzluksiz integratsiya qilib, resurslarni samarali boshqarish orqali ma'lumotlar oqimlarini qayta ishlashingiz mumkin. Mana bir misol:

            
async function* processStream(dataStream, resourcePool) {
  for await (const data of dataStream) {
    const resource = await resourcePool.acquire();
    try {
      // Olingan resurs yordamida ma'lumotlarni qayta ishlash
      const result = await processData(data, resource);
      yield result;
    } finally {
      resourcePool.release(resource);
    }
  }
}

async function processData(data, resource) {
  // Resurs bilan ma'lumotlarni qayta ishlashni simulyatsiya qilish
  await delay(50);
  return `${data} ma'lumoti ${resource.id} resursi bilan qayta ishlandi`;
}

(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
              
            
          

Ushbu misolda, `processStream` ma'lumotlar oqimini iste'mol qiladigan va har bir elementni resurslar pulidan olingan resurs yordamida qayta ishlaydigan asinxron generator funksiyasidir. `try...finally` bloki qayta ishlash paytida xato yuz bergan taqdirda ham resursning har doim pulga qaytarilishini ta'minlaydi.

Resurslar Pulidan Foydalanishning Afzalliklari

• Unumdorlikni Oshirish: Resurslarni qayta ishlatish orqali har bir operatsiya uchun resurslarni yaratish va yo'q qilish bilan bog'liq qo'shimcha xarajatlardan qochishingiz mumkin.
• Nazorat Qilinadigan Konkurentlik: Resurslar puli bir vaqtda bajariladigan operatsiyalar sonini cheklaydi, resurslarning tugab qolishining oldini oladi va tizim barqarorligini oshiradi.
• Soddalashtirilgan Resurs Boshqaruvi: Resurslar puli resurslarni olish va bo'shatish mantig'ini o'z ichiga oladi, bu esa dasturingizda resurslarni boshqarishni osonlashtiradi.
• Yaxshilangan Xatolarni Qayta Ishlash: Resurslar puli xatolar yuz berganda ham resurslarning bo'shatilishini ta'minlashga yordam beradi, bu esa resurs sızıntılarını oldini oladi.

Ilg'or Mulohazalar

Resurslarni Tasdiqlash

Resurslarni ishlatishdan oldin ularning hali ham yaroqliligini tekshirish muhim. Masalan, ma'lumotlar bazasi ulanishini ishlatishdan oldin uning hali ham faol ekanligini tekshirishni xohlashingiz mumkin. Agar resurs yaroqsiz bo'lsa, uni yo'q qilib, puldan yangisini olishingiz mumkin.

            
class ResourcePool {
  // ... (oldingi kod) ...

  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("Yaroqsiz resurs aniqlandi, yo'q qilinib, yangisi olinmoqda.");
          await this.resourceDestroyer(resource);
          // Boshqa resurs olishga urinish (tsikl davom etadi)
        }
      } else {
        return new Promise(resolve => {
          this.waitingQueue.push(resolve);
        });
      }
    }
  }

  async isValidResource(resource) {
    // Bu yerda resursni tekshirish mantig'ini amalga oshiring
    // Masalan, ma'lumotlar bazasi ulanishi hali ham faol ekanligini tekshiring
    try {
        // Tekshiruvni simulyatsiya qilish
        await delay(10);
        return true; // Ushbu misol uchun yaroqli deb hisoblaymiz
    } catch (error) {
        console.error("Resurs yaroqsiz:", error);
        return false;
    }
  }

  // ... (kodning qolgan qismi) ...
}

            

              
                Copy
              
            
          

Resurs Taymauti

Operatsiyalarning resursni cheksiz kutishini oldini olish uchun taymaut mexanizmini joriy qilishni xohlashingiz mumkin. Agar operatsiya taymautdan oshib ketsa, siz promise-ni rad etishingiz va xatoni mos ravishda qayta ishlashingiz mumkin.

            
class ResourcePool {
    // ... (oldingi kod) ...

    async acquire(timeout = 5000) { // Standart 5 soniyalik taymaut
        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 {
                    // Resurs darhol mavjud emas, qisqa kechikishdan so'ng qayta urinib ko'ring
                    setTimeout(acquireResource, 50);
                }
            };

            timeoutId = setTimeout(() => {
                reject(new Error("Puldan resurs olishda taymaut."));
            }, timeout);

            acquireResource(); // Darhol olishga urinishni boshlash
        });
    }

    // ... (kodning qolgan qismi) ...
}

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

    try {
        const connection = await dbPool.acquire(2000); // 2 soniyalik taymaut bilan olish
        console.log("Olingan ulanish:", connection.id);
        dbPool.release(connection);
    } catch (error) {
        console.error("Ulanishni olishda xato:", error.message);
    }

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

            

              
                Copy
              
            
          

Monitoring va Metrikalar

Resurslar pulidan foydalanishni kuzatish uchun monitoring va metrikalarni joriy qiling. Bu sizga to'siqlarni aniqlashga va pul hajmi hamda resurs taqsimotini optimallashtirishga yordam beradi.

• Mavjud resurslar soni.
• Olingan resurslar soni.
• Kutilayotgan so'rovlar soni.
• O'rtacha olish vaqti.

Haqiqiy Hayotdagi Qo'llash Holatlari

• Ma'lumotlar bazasi ulanishlarini birlashtirish (Pooling): Bir vaqtda bajariladigan so'rovlarni boshqarish uchun ma'lumotlar bazasi ulanishlari pulini boshqarish. Bu elektron tijorat platformalari yoki kontentni boshqarish tizimlari kabi ma'lumotlar bazalari bilan ko'p ishlaydigan dasturlarda keng tarqalgan. Masalan, global elektron tijorat sayti kechikishni optimallashtirish uchun turli mintaqalar uchun turli ma'lumotlar bazasi pullariga ega bo'lishi mumkin.
• API So'rovlarini Cheklash: Tashqi API-larga yuboriladigan so'rovlar sonini nazorat qilib, so'rov chegaralaridan oshib ketmaslik. Ko'pgina API-lar, ayniqsa ijtimoiy media platformalari yoki bulutli xizmatlardan olinganlar, suiiste'mol qilishning oldini olish uchun so'rov chegaralarini qo'llaydi. Resurslar puli mavjud API tokenlari yoki ulanish slotlarini boshqarish uchun ishlatilishi mumkin. Tasavvur qiling, bir nechta aviakompaniya API-lari bilan integratsiyalashgan sayohat bron qilish sayti; resurslar puli bir vaqtda bajariladigan API chaqiruvlarini boshqarishga yordam beradi.
• Fayllarni Qayta Ishlash: Disk I/O to'siqlarini oldini olish uchun bir vaqtda bajariladigan fayl o'qish/yozish operatsiyalari sonini cheklash. Bu, ayniqsa, katta fayllarni qayta ishlashda yoki konkurentlik cheklovlariga ega bo'lgan saqlash tizimlari bilan ishlaganda muhim. Masalan, media transkodlash xizmati bir vaqtning o'zida video kodlash jarayonlari sonini cheklash uchun resurslar pulidan foydalanishi mumkin.
• Veb Soket Ulanishlarini Boshqarish: Turli serverlar yoki xizmatlarga veb soket ulanishlari pulini boshqarish. Resurslar puli unumdorlik va ishonchlilikni oshirish uchun istalgan vaqtda ochiladigan ulanishlar sonini cheklashi mumkin. Misol: chat serveri yoki real vaqt rejimida savdo platformasi.

Resurslar Puliga Alternativalar

Resurslar pullari samarali bo'lsa-da, konkurentlik va resurslardan foydalanishni boshqarish uchun boshqa yondashuvlar ham mavjud:

• Navbatlar: Ishlab chiqaruvchilar va iste'molchilarni ajratish uchun xabarlar navbatidan foydalaning, bu sizga xabarlarni qayta ishlash tezligini nazorat qilish imkonini beradi. RabbitMQ yoki Kafka kabi xabarlar navbatlari asinxron vazifalarni qayta ishlash uchun keng qo'llaniladi.
• Semaforlar: Semafor — bu umumiy resursga bir vaqtda kirishlar sonini cheklash uchun ishlatilishi mumkin bo'lgan sinxronizatsiya primitividir.
• Konkurentlik Kutubxonalari: `p-limit` kabi kutubxonalar asinxron operatsiyalarda konkurentlikni cheklash uchun oddiy API-larni taqdim etadi.

Yondashuvni tanlash dasturingizning o'ziga xos talablariga bog'liq.

Xulosa

Asinxron iteratorlar va yordamchi funksiyalar resurslar puli bilan birgalikda JavaScript-da asinxron resurslarni boshqarishning kuchli va moslashuvchan usulini ta'minlaydi. Konkurentlikni nazorat qilish, resurslarning tugab qolishining oldini olish va resurslarni boshqarishni soddalashtirish orqali siz yanada mustahkam va unumdor dasturlar yaratishingiz mumkin. Samarali resurslardan foydalanishni talab qiladigan I/O bilan bog'liq operatsiyalar bilan ishlaganda resurslar pulidan foydalanishni o'ylab ko'ring. Optimal unumdorlikni ta'minlash uchun resurslaringizni tasdiqlashni, taymaut mexanizmlarini joriy qilishni va resurslar pulidan foydalanishni kuzatib borishni unutmang. Ushbu printsiplarni tushunib va qo'llab, siz zamonaviy veb-ishlab chiqish talablariga javob bera oladigan yanada kengaytiriladigan va ishonchli asinxron dasturlar yaratishingiz mumkin.