Web Workers Oqimlar Puli: Fon Vazifalarini Taqsimlash va Yuklamani Balanslash

Bugungi murakkab veb-ilovalarda ijobiy foydalanuvchi tajribasini ta'minlash uchun sezgirlikni saqlab qolish juda muhim. Hisoblash talab qiladigan yoki tashqi resurslarni kutishni o'z ichiga olgan (tarmoq so'rovlari yoki ma'lumotlar bazasi so'rovlari kabi) amallar asosiy oqimni bloklashi mumkin, bu esa foydalanuvchi interfeysining (UI) muzlashiga va sekin ishlashiga olib keladi. Web Workers sizga JavaScript kodini fon oqimlarida ishga tushirish imkonini berib, asosiy oqimni UI yangilanishlari va foydalanuvchi bilan o'zaro aloqalar uchun bo'shatib, kuchli yechim taklif qiladi.

Biroq, bir nechta Web Worker'larni to'g'ridan-to'g'ri boshqarish, ayniqsa ko'p sonli vazifalar bilan ishlaganda, noqulay bo'lib qolishi mumkin. Aynan shu yerda Web Workers oqimlar puli tushunchasi ishga tushadi. Oqimlar puli vazifalarni dinamik ravishda tayinlash mumkin bo'lgan boshqariladigan Web Worker'lar to'plamini taqdim etadi, bu esa resurslardan foydalanishni optimallashtiradi va fon vazifalarini taqsimlashni soddalashtiradi.

Web Workers Oqimlar Puli nima?

Web Workers oqimlar puli — bu belgilangan yoki dinamik miqdordagi Web Worker'larni yaratish va ularning hayot siklini boshqarishni o'z ichiga olgan dizayn naqshidir. Har bir vazifa uchun Web Worker'larni yaratish va yo'q qilish o'rniga, oqimlar puli qayta ishlatilishi mumkin bo'lgan mavjud worker'lar pulini saqlaydi. Bu worker'larni yaratish va tugatish bilan bog'liq qo'shimcha xarajatlarni sezilarli darajada kamaytiradi, bu esa unumdorlik va resurs samaradorligini oshirishga olib keladi.

Buni har biri ma'lum bir turdagi vazifani bajarishga tayyor bo'lgan ixtisoslashgan ishchilar jamoasi deb o'ylang. Biror ishni bajarish kerak bo'lganda har safar ishchilarni yollash va ishdan bo'shatish o'rniga, sizda vazifalar paydo bo'lganda ularni tayinlashni kutayotgan tayyor jamoa mavjud bo'ladi.

Web Workers Oqimlar Pulidan foydalanishning afzalliklari

• Yaxshilangan Unumdorlik: Web Worker'larni qayta ishlatish ularni yaratish va yo'q qilish bilan bog'liq qo'shimcha xarajatlarni kamaytiradi, bu esa vazifalarni tezroq bajarishga olib keladi.
• Soddalashtirilgan Vazifalarni Boshqarish: Oqimlar puli fon vazifalarini boshqarish uchun markazlashtirilgan mexanizmni taqdim etadi, bu esa umumiy ilova arxitekturasini soddalashtiradi.
• Yuklamani Balanslash: Vazifalar mavjud worker'lar o'rtasida teng taqsimlanishi mumkin, bu esa bitta worker'ning haddan tashqari yuklanishini oldini oladi.
• Resurslarni Optimallashtirish: Puldagi worker'lar soni mavjud resurslar va ish yukiga qarab sozlanishi mumkin, bu esa resurslardan optimal foydalanishni ta'minlaydi.
• Sezgirlikning Oshishi: Hisoblash talab qiladigan vazifalarni fon oqimlariga o'tkazish orqali, asosiy oqim UI yangilanishlari va foydalanuvchi bilan o'zaro aloqalarni bajarish uchun bo'sh qoladi, bu esa ilovaning sezgirligini oshiradi.

Web Workers Oqimlar Pulini Amalga Oshirish

Web Workers oqimlar pulini amalga oshirish bir nechta asosiy komponentlarni o'z ichiga oladi:

1. Worker Yaratish: Web Worker'lar pulini yarating va ularni massiv yoki boshqa ma'lumotlar tuzilmasida saqlang.
2. Vazifalar Navbati: Bajarilishini kutayotgan vazifalar navbatini saqlang.
3. Vazifalarni Tayinlash: Worker bo'sh bo'lganda, unga navbatdan vazifa tayinlang.
4. Natijalarni Qayta Ishlash: Worker vazifani tugatganda, natijani oling va tegishli qayta chaqiruv funksiyasini (callback function) xabardor qiling.
5. Worker'ni Qayta Ishlatish: Worker vazifani tugatgandan so'ng, uni qayta ishlatish uchun pulga qaytaring.

Mana JavaScript'dagi soddalashtirilgan misol:

            
class ThreadPool {
  constructor(size) {
    this.size = size;
    this.workers = [];
    this.taskQueue = [];
    this.availableWorkers = [];

    for (let i = 0; i < size; i++) {
      const worker = new Worker('worker.js'); // worker.js fayli mavjudligiga va worker logikasini o'z ichiga olganligiga ishonch hosil qiling
      worker.onmessage = (event) => {
        const { taskId, result } = event.data;
        // Natijani qayta ishlang, masalan, vazifa bilan bog'liq va'dani (promise) bajaring
        this.taskCompletion(taskId, result, worker);
      };
      worker.onerror = (error) => {
        console.error('Worker xatosi:', error);
        // Xatolikni qayta ishlang, ehtimol va'dani (promise) rad eting
        this.taskError(error, worker);
      };
      this.workers.push(worker);
      this.availableWorkers.push(worker);
    }
  }

  enqueue(task, taskId) {
    return new Promise((resolve, reject) => {
      this.taskQueue.push({ task, resolve, reject, taskId });
      this.processTasks();
    });
  }

  processTasks() {
    while (this.availableWorkers.length > 0 && this.taskQueue.length > 0) {
      const worker = this.availableWorkers.shift();
      const { task, resolve, reject, taskId } = this.taskQueue.shift();
      worker.postMessage({ task, taskId }); // Vazifa va taskId'ni workerga yuboring
    }
  }

  taskCompletion(taskId, result, worker) {
    // Navbatdagi vazifani toping (murakkab holatlar uchun zarur bo'lsa)
    // Vazifa bilan bog'liq va'dani (promise) bajaring
    const taskData = this.workers.find(w => w === worker);

    // Natijani qayta ishlang (masalan, UI'ni yangilang)
    // Vazifa bilan bog'liq va'dani (promise) bajaring
    const taskIndex = this.taskQueue.findIndex(t => t.taskId === taskId);
    if(taskIndex !== -1){
        this.taskQueue.splice(taskIndex, 1); //bajarilgan vazifalarni o'chirish
    }
    this.availableWorkers.push(worker);
    this.processTasks();

    // Natijadan foydalanib, vazifa bilan bog'liq va'dani (promise) bajaring
  }

  taskError(error, worker) {
      //Workerdan kelgan xatoni shu yerda qayta ishlang
      console.error("vazifa xatosi", error);
      this.availableWorkers.push(worker);
      this.processTasks();
  }
}

// Foydalanish namunasi:
const pool = new ThreadPool(4); // 4 ta workerdan iborat pul yarating

async function doWork() {
  const task1 = pool.enqueue({ action: 'calculateSum', data: [1, 2, 3, 4, 5] }, 'task1');
  const task2 = pool.enqueue({ action: 'multiply', data: [2, 3, 4, 5, 6] }, 'task2');
  const task3 = pool.enqueue({ action: 'processImage', data: 'image_data' }, 'task3');
  const task4 = pool.enqueue({ action: 'fetchData', data: 'https://example.com/data' }, 'task4');

  const results = await Promise.all([task1, task2, task3, task4]);
  console.log('Natijalar:', results);
}

doWork();

            

              
                Copy
              
            
          

worker.js (namuna worker skripti):

            
self.onmessage = (event) => {
  const { task, taskId } = event.data;
  let result;

  switch (task.action) {
    case 'calculateSum':
      result = task.data.reduce((a, b) => a + b, 0);
      break;
    case 'multiply':
      result = task.data.reduce((a, b) => a * b, 1);
      break;
    case 'processImage':
      // Rasmga ishlov berishni simulyatsiya qilish (haqiqiy rasmga ishlov berish logikasi bilan almashtiring)
      result = 'Rasm muvaffaqiyatli qayta ishlandi!';
      break;
    case 'fetchData':
      //Ma'lumotlarni olishni simulyatsiya qilish
      result = 'Ma\'lumotlar muvaffaqiyatli olindi';
      break;
    default:
      result = 'Noma\'lum harakat';
  }

  self.postMessage({ taskId, result }); // Natijani asosiy oqimga qayta yuboring, taskId'ni ham qo'shib
};

            

              
                Copy
              
            
          

Kodning Izohi:

• ThreadPool Klassi:
  • Konstruktor: Oqimlar pulini belgilangan o'lcham bilan ishga tushiradi. U belgilangan miqdordagi worker'larni yaratadi, har bir worker'dan keladigan xabarlar va xatoliklarni qayta ishlash uchun `onmessage` va `onerror` hodisa tinglovchilarini biriktiradi va ularni `workers` va `availableWorkers` massivlariga qo'shadi.
  • enqueue(task, taskId): Vazifani `taskQueue`'ga qo'shadi. U vazifa natijasi bilan bajariladigan yoki xatolik yuzaga kelsa rad etiladigan `Promise`ni qaytaradi. Vazifa navbatga `resolve`, `reject` va `taskId` bilan birga qo'shiladi.
  • processTasks(): Bo'sh worker'lar va navbatda vazifalar borligini tekshiradi. Agar shunday bo'lsa, u worker va vazifani navbatdan oladi va `postMessage` yordamida vazifani worker'ga yuboradi.
  • taskCompletion(taskId, result, worker): Bu usul worker vazifani tugatganda chaqiriladi. U vazifani `taskQueue` dan oladi, bog'liq `Promise`ni natija bilan bajaradi va worker'ni `availableWorkers` massiviga qaytaradi. Keyin, agar mavjud bo'lsa, yangi vazifani boshlash uchun `processTasks()`'ni chaqiradi.
  • taskError(error, worker): Bu usul worker xatolikka duch kelganda chaqiriladi. U xatoni qayd etadi, worker'ni `availableWorkers` massiviga qaytaradi va agar mavjud bo'lsa, yangi vazifani boshlash uchun `processTasks()`'ni chaqiradi. Ilovaning ishdan chiqishini oldini olish uchun xatoliklarni to'g'ri qayta ishlash muhimdir.
• Worker Skripti (worker.js):
  • onmessage: Bu hodisa tinglovchisi worker asosiy oqimdan xabar olganda ishga tushadi. U hodisa ma'lumotlaridan vazifa va taskId'ni ajratib oladi.
  • Vazifani Qayta Ishlash: `switch` operatori vazifada ko'rsatilgan `action`'ga qarab turli kodlarni bajarish uchun ishlatiladi. Bu worker'ga turli xil amallarni bajarish imkonini beradi.
  • postMessage: Vazifani qayta ishlagandan so'ng, worker `postMessage` yordamida natijani asosiy oqimga qaytaradi. Natija taskId'ni o'z ichiga oladi, bu asosiy oqimda vazifalar va ularning tegishli promise'larini kuzatib borish uchun juda muhimdir.

Muhim Mulohazalar:

• Xatoliklarni Qayta Ishlash: Kod worker ichida va asosiy oqimda asosiy xatoliklarni qayta ishlashni o'z ichiga oladi. Biroq, ishdan chiqishlarni oldini olish va ilova barqarorligini ta'minlash uchun ishlab chiqarish muhitida mustahkam xatoliklarni qayta ishlash strategiyalari juda muhimdir.
• Vazifalarni Serializatsiya qilish: Web Worker'larga uzatiladigan ma'lumotlar serializatsiya qilinadigan bo'lishi kerak. Bu degani, ma'lumotlar asosiy oqim va worker o'rtasida uzatilishi mumkin bo'lgan satr ko'rinishiga aylantirilishi kerak. Murakkab obyektlar maxsus serializatsiya usullarini talab qilishi mumkin.
• Worker Skriptining Joylashuvi: `worker.js` fayli asosiy HTML fayli bilan bir xil manbadan taqdim etilishi kerak, yoki agar worker skripti boshqa domenda joylashgan bo'lsa, CORS to'g'ri sozlangan bo'lishi kerak.

Yuklamani Balanslash Strategiyalari

Yuklamani balanslash - bu vazifalarni mavjud resurslar o'rtasida teng taqsimlash jarayonidir. Web Workers oqimlar puli kontekstida yuklamani balanslash hech bir worker'ning haddan tashqari yuklanmasligini ta'minlaydi, umumiy unumdorlik va sezgirlikni maksimal darajaga yetkazadi.

Quyida keng tarqalgan yuklamani balanslash strategiyalari keltirilgan:

• Round Robin: Vazifalar worker'larga aylanma tartibda tayinlanadi. Bu vazifalarni teng taqsimlash uchun oddiy va samarali strategiya.
• Eng Kam Ulanishlar: Vazifalar eng kam faol ulanishlarga ega bo'lgan (ya'ni, hozirda eng kam vazifalarni bajarayotgan) worker'ga tayinlanadi. Bu strategiya vazifalar turli bajarilish vaqtlariga ega bo'lganda round robin'dan ko'ra samaraliroq bo'lishi mumkin.
• Vaznli Yuklamani Balanslash: Har bir worker'ga uning qayta ishlash quvvatiga qarab vazn beriladi. Vazifalar worker'larga ularning vazniga qarab tayinlanadi, bu esa kuchliroq worker'larning ish yukining katta qismini bajarishini ta'minlaydi.
• Dinamik Yuklamani Balanslash: Puldagi worker'lar soni joriy ish yukiga qarab dinamik ravishda sozlanadi. Bu strategiya ish yuki vaqt o'tishi bilan sezilarli darajada o'zgarganda ayniqsa samarali bo'lishi mumkin. Bu CPU'dan foydalanish yoki vazifalar navbati uzunligiga qarab pulga worker qo'shish yoki olib tashlashni o'z ichiga olishi mumkin.

Yuqoridagi kod namunasi yuklamani balanslashning asosiy shaklini namoyish etadi: vazifalar mavjud worker'larga navbatga kelish tartibida (FIFO) tayinlanadi. Bu yondashuv vazifalar nisbatan bir xil bajarilish vaqtlariga ega bo'lganda yaxshi ishlaydi. Biroq, murakkabroq stsenariylar uchun sizga yanada murakkab yuklamani balanslash strategiyasini amalga oshirish kerak bo'lishi mumkin.

Ilg'or Texnikalar va Mulohazalar

Asosiy amalga oshirishdan tashqari, Web Workers oqimlar puli bilan ishlashda yodda tutish kerak bo'lgan bir nechta ilg'or texnikalar va mulohazalar mavjud:

• Worker'lar O'rtasidagi Aloqa: Vazifalarni worker'larga yuborishdan tashqari, siz Web Worker'lardan bir-biri bilan aloqa qilish uchun ham foydalanishingiz mumkin. Bu murakkab parallel algoritmlarni amalga oshirish yoki worker'lar o'rtasida ma'lumotlarni almashish uchun foydali bo'lishi mumkin. Worker'lar o'rtasida ma'lumot yuborish uchun `postMessage`'dan foydalaning.
• Shared Array Buffers: Shared Array Buffers (SABs) asosiy oqim va Web Worker'lar o'rtasida xotirani almashish mexanizmini taqdim etadi. Bu katta ma'lumotlar to'plamlari bilan ishlashda unumdorlikni sezilarli darajada oshirishi mumkin. SAB'lardan foydalanganda xavfsizlik oqibatlaridan xabardor bo'ling. SAB'lar Spectre/Meltdown zaifliklari tufayli maxsus sarlavhalarni (COOP va COEP) yoqishni talab qiladi.
• OffscreenCanvas: OffscreenCanvas sizga asosiy oqimni bloklamasdan Web Worker'da grafiklarni render qilish imkonini beradi. Bu murakkab animatsiyalarni amalga oshirish yoki fonda rasmga ishlov berish uchun foydali bo'lishi mumkin.
• WebAssembly (WASM): WebAssembly sizga brauzerda yuqori unumdorlikdagi kodni ishga tushirish imkonini beradi. Veb-ilovalaringizning unumdorligini yanada oshirish uchun Web Worker'larni WebAssembly bilan birgalikda ishlatishingiz mumkin. WASM modullari Web Worker'lar ichida yuklanishi va bajarilishi mumkin.
• Bekor Qilish Tokenlari: Bekor qilish tokenlarini amalga oshirish sizga veb worker'lar ichida ishlayotgan uzoq davom etadigan vazifalarni chiroyli tarzda to'xtatish imkonini beradi. Bu foydalanuvchi harakati yoki boshqa hodisalar vazifani bajarilish o'rtasida to'xtatishni talab qilishi mumkin bo'lgan stsenariylar uchun juda muhimdir.
• Vazifalarni Ustuvorlashtirish: Vazifalar uchun ustuvorlik navbatini amalga oshirish sizga muhim vazifalarga yuqori ustuvorlik berish imkonini beradi, bu ularning kamroq muhimlaridan oldin bajarilishini ta'minlaydi. Bu silliq foydalanuvchi tajribasini saqlab qolish uchun ma'lum vazifalarni tezda bajarish kerak bo'lgan stsenariylarda foydalidir.

Haqiqiy Dunyo Misollari va Qo'llash Holatlari

Web Workers oqimlar puli turli xil ilovalarda ishlatilishi mumkin, jumladan:

• Rasm va Videoga Ishlov Berish: Rasm yoki videoga ishlov berish vazifalarini fonda bajarish veb-ilovalarning sezgirligini sezilarli darajada yaxshilashi mumkin. Masalan, onlayn foto muharriri asosiy oqimni bloklamasdan filtrlarni qo'llash yoki rasmlar hajmini o'zgartirish uchun oqimlar pulidan foydalanishi mumkin.
• Ma'lumotlar Tahlili va Vizualizatsiyasi: Katta ma'lumotlar to'plamlarini tahlil qilish va vizualizatsiyalarni yaratish hisoblash jihatidan intensiv bo'lishi mumkin. Oqimlar pulidan foydalanish ish yukini bir nechta worker'larga taqsimlab, tahlil va vizualizatsiya jarayonini tezlashtirishi mumkin. Fond bozori ma'lumotlarini real vaqtda tahlil qiladigan moliyaviy boshqaruv panelini tasavvur qiling; Web Worker'lardan foydalanish hisob-kitoblar paytida UI'ning muzlashini oldini oladi.
• O'yinlarni Ishlab Chiqish: O'yin mantig'i va renderlashni fonda bajarish veb-asosidagi o'yinlarning unumdorligi va sezgirligini yaxshilashi mumkin. Masalan, o'yin dvigateli fizika simulyatsiyalarini hisoblash yoki murakkab sahnalarni render qilish uchun oqimlar pulidan foydalanishi mumkin.
• Mashinaviy Ta'lim: Mashinaviy ta'lim modellarini o'qitish hisoblash jihatidan intensiv vazifa bo'lishi mumkin. Oqimlar pulidan foydalanish ish yukini bir nechta worker'larga taqsimlab, o'qitish jarayonini tezlashtirishi mumkin. Masalan, tasvirni aniqlash modellarini o'qitish uchun veb-ilova rasm ma'lumotlarini parallel qayta ishlash uchun Web Worker'lardan foydalanishi mumkin.
• Kodni Kompilyatsiya va Transpilyatsiya qilish: Brauzerda kodni kompilyatsiya yoki transpilyatsiya qilish sekin bo'lishi va asosiy oqimni bloklashi mumkin. Oqimlar pulidan foydalanish ish yukini bir nechta worker'larga taqsimlab, kompilyatsiya yoki transpilyatsiya jarayonini tezlashtirishi mumkin. Masalan, onlayn kod muharriri TypeScript'ni transpilyatsiya qilish yoki C++ kodini WebAssembly'ga kompilyatsiya qilish uchun oqimlar pulidan foydalanishi mumkin.
• Kriptografik Amallar: Xeshlash yoki shifrlash kabi kriptografik amallarni bajarish hisoblash jihatidan qimmat bo'lishi mumkin. Web Worker'lar ushbu amallarni fonda bajarib, asosiy oqimning bloklanishini oldini oladi.
• Tarmoq va Ma'lumotlarni Olish: `fetch` yoki `XMLHttpRequest` yordamida tarmoq orqali ma'lumotlarni olish o'z-o'zidan asinxron bo'lsa-da, ma'lumotlarni olgandan keyingi murakkab qayta ishlash hali ham asosiy oqimni bloklashi mumkin. Worker oqimlar puli ma'lumotlarni UI'da ko'rsatilishidan oldin fonda tahlil qilish va o'zgartirish uchun ishlatilishi mumkin.

Misol Stsenariy: Global Elektron Tijorat Platformasi

Dunyo bo'ylab foydalanuvchilarga xizmat ko'rsatadigan yirik elektron tijorat platformasini ko'rib chiqing. Platforma turli xil fon vazifalarini bajarishi kerak, masalan:

• Buyurtmalarni qayta ishlash va inventarni yangilash
• Shaxsiylashtirilgan tavsiyalarni yaratish
• Marketing kampaniyalari uchun foydalanuvchi xulq-atvorini tahlil qilish
• Turli mintaqalar uchun valyuta konvertatsiyalari va soliq hisob-kitoblarini bajarish

Web Workers oqimlar pulidan foydalanib, platforma ushbu vazifalarni bir nechta worker'larga taqsimlashi mumkin, bu esa asosiy oqimning sezgir bo'lib qolishini ta'minlaydi. Platforma, shuningdek, ish yukini worker'lar o'rtasida teng taqsimlash uchun yuklamani balanslashni amalga oshirishi mumkin, bu esa bitta worker'ning haddan tashqari yuklanishini oldini oladi. Bundan tashqari, ma'lum worker'lar valyuta konvertatsiyalari va soliq hisob-kitoblari kabi mintaqaga xos vazifalarni bajarish uchun moslashtirilishi mumkin, bu esa dunyoning turli burchaklaridagi foydalanuvchilar uchun optimal unumdorlikni ta'minlaydi.

Xalqarolashtirish uchun vazifalarning o'zi mahalliy sozlamalardan xabardor bo'lishi kerak bo'lishi mumkin, bu esa worker skriptining dinamik ravishda yaratilishini yoki vazifa ma'lumotlarining bir qismi sifatida mahalliy ma'lumotlarni qabul qilishini talab qiladi. `Intl` kabi kutubxonalar lokalizatsiyaga xos operatsiyalarni bajarish uchun worker ichida ishlatilishi mumkin.

Xulosa

Web Workers oqimlar puli veb-ilovalarning unumdorligi va sezgirligini yaxshilash uchun kuchli vositadir. Hisoblash talab qiladigan vazifalarni fon oqimlariga o'tkazish orqali siz asosiy oqimni UI yangilanishlari va foydalanuvchi bilan o'zaro aloqalar uchun bo'shatishingiz mumkin, bu esa silliqroq va yoqimliroq foydalanuvchi tajribasiga olib keladi. Samarali yuklamani balanslash strategiyalari va ilg'or texnikalar bilan birgalikda, Web Workers oqimlar puli veb-ilovalaringizning kengayishi va samaradorligini sezilarli darajada oshirishi mumkin.

Siz oddiy veb-ilova yoki murakkab korporativ darajadagi tizim quryapsizmi, unumdorlikni optimallashtirish va global auditoriyangiz uchun yaxshiroq foydalanuvchi tajribasini taqdim etish uchun Web Workers oqimlar pulidan foydalanishni o'ylab ko'ring.