JavaScript Modul Workerlar: Global Raqamli Dunyo uchun Fon Jarayonlari Shakllarini O'zlashtirish

            
// worker.js

// Bu funksiya worker xabar olganda ishga tushadi
self.onmessage = function(event) {
  const data = event.data;
  console.log('Workerdagi qabul qilingan xabar:', data);

  // Qandaydir fon vazifasini bajarish
  const result = data.value * 2;

  // Natijani asosiy oqimga qaytarib yuborish
  self.postMessage({ result: result });
};

console.log('Modul Worker ishga tushirildi.');

            

              
                Copy
              
            
          

            
// main.js

// Modul Workerlar qo'llab-quvvatlanishini tekshirish
if (window.Worker) {
  // Yangi Modul Worker yaratish
  // Eslatma: Yo'l modul fayliga (ko'pincha .js kengaytmali) ishora qilishi kerak
  const myWorker = new Worker('./worker.js', { type: 'module' });

  // Workerdan keladigan xabarlarni tinglash
  myWorker.onmessage = function(event) {
    console.log('Workerdan qabul qilingan xabar:', event.data);
  };

  // Workerga xabar yuborish
  myWorker.postMessage({ value: 10 });

  // Xatolarni ham qayta ishlashingiz mumkin
  myWorker.onerror = function(error) {
    console.error('Worker xatosi:', error);
  };
} else {
  console.log('Sizning brauzeringiz Web Workerlarni qo\'llab-quvvatlamaydi.');
}

            

              
                Copy
              
            
          

            
// worker.js

let taskQueue = [];
let isProcessing = false;

async function processTask(task) {
  console.log(`Vazifa qayta ishlanmoqda: ${task.type}`);
  // Hisoblash jihatidan og'ir operatsiyani simulyatsiya qilish
  await new Promise(resolve => setTimeout(resolve, task.duration || 1000));
  return `Vazifa ${task.type} bajarildi.`;
}

async function runQueue() {
  if (isProcessing || taskQueue.length === 0) {
    return;
  }

  isProcessing = true;
  const currentTask = taskQueue.shift();

  try {
    const result = await processTask(currentTask);
    self.postMessage({ status: 'success', taskId: currentTask.id, result: result });
  } catch (error) {
    self.postMessage({ status: 'error', taskId: currentTask.id, error: error.message });
  } finally {
    isProcessing = false;
    runQueue(); // Keyingi vazifani qayta ishlash
  }
}

self.onmessage = function(event) {
  const { type, data, taskId } = event.data;

  if (type === 'addTask') {
    taskQueue.push({ id: taskId, ...data });
    runQueue();
  } else if (type === 'processAll') {
    // Navbatdagi har qanday vazifani darhol qayta ishlashga urinish
    runQueue();
  }
};

console.log('Vazifalar Navbati Workeri ishga tushirildi.');

            

              
                Copy
              
            
          

            
// main.js

if (window.Worker) {
  const taskWorker = new Worker('./worker.js', { type: 'module' });
  let taskIdCounter = 0;

  taskWorker.onmessage = function(event) {
    console.log('Worker xabari:', event.data);
    if (event.data.status === 'success') {
      // Muvaffaqiyatli vazifa bajarilishini qayta ishlash
      console.log(`Vazifa ${event.data.taskId} natija bilan yakunlandi: ${event.data.result}`);
    } else if (event.data.status === 'error') {
      // Vazifa xatolarini qayta ishlash
      console.error(`Vazifa ${event.data.taskId} bajarilmadi: ${event.data.error}`);
    }
  };

  function addTaskToWorker(taskData) {
    const taskId = ++taskIdCounter;
    taskWorker.postMessage({ type: 'addTask', data: taskData, taskId: taskId });
    console.log(`Vazifa ${taskId} navbatga qo'shildi.`);
    return taskId;
  }

  // Foydalanish misoli: Bir nechta vazifa qo'shish
  addTaskToWorker({ type: 'image_resize', duration: 1500 });
  addTaskToWorker({ type: 'data_fetch', duration: 2000 });
  addTaskToWorker({ type: 'data_process', duration: 1200 });

  // Agar kerak bo'lsa, qayta ishlashni ixtiyoriy ravishda ishga tushirish (masalan, tugmani bosganda)
  // taskWorker.postMessage({ type: 'processAll' });

} else {
  console.log('Web Workerlar bu brauzerda qo\'llab-quvvatlanmaydi.');
}

            

              
                Copy
              
            
          

            
// data-analyzer.js

export function aggregateData(data) {
  console.log('Ma\'lumotlar workerda agregatsiyalanmoqda...');
  // Murakkab agregatsiyani simulyatsiya qilish
  let sum = 0;
  for (let i = 0; i < data.length; i++) {
    sum += data[i];
    // Hisoblashni simulyatsiya qilish uchun kichik kechikish kiritish
    // Haqiqiy senariyda bu haqiqiy hisoblash bo'ladi
    for(let j = 0; j < 1000; j++) { /* kechikish */ }
  }
  return { total: sum, count: data.length };
}

            

              
                Copy
              
            
          

            
// analyticsWorker.js

import { aggregateData } from './data-analyzer.js';

self.onmessage = function(event) {
  const { dataset } = event.data;
  if (!dataset) {
    self.postMessage({ status: 'error', message: 'Ma\'lumotlar to\'plami taqdim etilmagan' });
    return;
  }

  try {
    const result = aggregateData(dataset);
    self.postMessage({ status: 'success', result: result });
  } catch (error) {
    self.postMessage({ status: 'error', message: error.message });
  }
};

console.log('Tahlil Workeri ishga tushirildi.');

            

              
                Copy
              
            
          

            
// main.js

if (window.Worker) {
  const analyticsWorker = new Worker('./analyticsWorker.js', { type: 'module' });

  analyticsWorker.onmessage = function(event) {
    console.log('Tahlil natijasi:', event.data);
    if (event.data.status === 'success') {
      document.getElementById('results').innerText = `Jami: ${event.data.result.total}, Soni: ${event.data.result.count}`;
    } else {
      document.getElementById('results').innerText = `Xato: ${event.data.message}`;
    }
  };

  // Katta ma'lumotlar to'plamini tayyorlash (simulyatsiya)
  const largeDataset = Array.from({ length: 10000 }, (_, i) => i + 1);

  // Ma'lumotlarni qayta ishlash uchun workerga yuborish
  analyticsWorker.postMessage({ dataset: largeDataset });

} else {
  console.log('Web Workerlar qo\'llab-quvvatlanmaydi.');
}

            

              
                Copy
              
            
          

            
<div id="results">Ma'lumotlar qayta ishlanmoqda...</div>

            

              
                Copy
              
            
          

            
// cacheWorker.js

let cache = {};
let websocket = null;

function setupWebSocket() {
  // Haqiqiy WebSocket manzilingiz bilan almashtiring
  const wsUrl = 'wss://your-realtime-api.example.com/data';
  websocket = new WebSocket(wsUrl);

  websocket.onopen = () => {
    console.log('WebSocket ulandi.');
    // Boshlang'ich ma'lumotlarni yoki obunani so'rash
    websocket.send(JSON.stringify({ action: 'subscribe', topic: 'updates' }));
  };

  websocket.onmessage = (event) => {
    try {
      const message = JSON.parse(event.data);
      console.log('WS xabari qabul qilindi:', message);
      if (message.type === 'update') {
        cache[message.key] = message.value;
        // Asosiy oqimni yangilangan kesh haqida xabardor qilish
        self.postMessage({ type: 'cache_update', key: message.key, value: message.value });
      }
    } catch (e) {
      console.error('WebSocket xabarini tahlil qilishda xatolik:', e);
    }
  };

  websocket.onerror = (error) => {
    console.error('WebSocket xatosi:', error);
    // Bir oz kechikishdan so'ng qayta ulanishga harakat qilish
    setTimeout(setupWebSocket, 5000);
  };

  websocket.onclose = () => {
    console.log('WebSocket uzildi. Qayta ulanmoqda...');
    setTimeout(setupWebSocket, 5000);
  };
}

self.onmessage = function(event) {
  const { type, data, key } = event.data;

  if (type === 'init') {
    // Agar WS tayyor bo'lmasa, API-dan boshlang'ich ma'lumotlarni olish mumkin
    // Sodda bo'lishi uchun, bu yerda WS ga tayanamiz.
    setupWebSocket();
  } else if (type === 'get') {
    const cachedValue = cache[key];
    self.postMessage({ type: 'cache_response', key: key, value: cachedValue });
  } else if (type === 'set') {
    cache[key] = data;
    self.postMessage({ type: 'cache_update', key: key, value: data });
    // Agar kerak bo'lsa, yangilanishlarni serverga yuborish
    if (websocket && websocket.readyState === WebSocket.OPEN) {
      websocket.send(JSON.stringify({ action: 'update', key: key, value: data }));
    }
  }
};

console.log('Kesh Workeri ishga tushirildi.');

// Ixtiyoriy: Agar worker to'xtatilsa, tozalash mantiqini qo'shish
self.onclose = () => {
  if (websocket) {
    websocket.close();
  }
};

            

              
                Copy
              
            
          

            
// main.js

if (window.Worker) {
  const cacheWorker = new Worker('./cacheWorker.js', { type: 'module' });

  cacheWorker.onmessage = function(event) {
    console.log('Kesh workerining xabari:', event.data);
    if (event.data.type === 'cache_update') {
      console.log(`Kalit uchun kesh yangilandi: ${event.data.key}`);
      // Agar kerak bo'lsa, UI elementlarini yangilash
    }
  };

  // Workerni va WebSocket ulanishini ishga tushirish
  cacheWorker.postMessage({ type: 'init' });

  // Keyinroq, keshdagi ma'lumotlarni so'rash
  setTimeout(() => {
    cacheWorker.postMessage({ type: 'get', key: 'userProfile' });
  }, 3000); // Boshlang'ich ma'lumotlar sinxronizatsiyasi uchun biroz kutish

  // Qiymatni o'rnatish uchun
  setTimeout(() => {
    cacheWorker.postMessage({ type: 'set', key: 'userSettings', data: { theme: 'dark' } });
  }, 5000);

} else {
  console.log('Web Workerlar qo\'llab-quvvatlanmaydi.');
}

            

              
                Copy
              
            
          

            
// imageProcessorWorker.js

let imageProcessorModule = null;

async function initializeWasm() {
  try {
    // Wasm modulini dinamik ravishda import qilish
    // './image_processor.wasm' yo'li mavjud bo'lishi kerak.
    // Wasm importlarini qayta ishlash uchun qurish vositangizni sozlashingiz kerak bo'lishi mumkin.
    const response = await fetch('./image_processor.wasm');
    const buffer = await response.arrayBuffer();
    const module = await WebAssembly.instantiate(buffer, {
      // Kerakli xost funksiyalari yoki modullarni bu yerga import qiling
      env: {
        log: (value) => console.log('Wasm Log:', value),
        // Misol: Workerdan Wasm-ga funksiya uzatish
        // Bu murakkab, ko'pincha ma'lumotlar umumiy xotira (ArrayBuffer) orqali uzatiladi
      }
    });
    imageProcessorModule = module.instance.exports;
    console.log('WebAssembly moduli yuklandi va instansiyalandi.');
    self.postMessage({ status: 'wasm_ready' });
  } catch (error) {
    console.error('Wasm-ni yuklash yoki instansiyalashda xatolik:', error);
    self.postMessage({ status: 'wasm_error', message: error.message });
  }
}

self.onmessage = async function(event) {
  const { type, imageData, width, height } = event.data;

  if (type === 'process_image') {
    if (!imageProcessorModule) {
      self.postMessage({ status: 'error', message: 'Wasm moduli tayyor emas.' });
      return;
    }

    try {
      // Wasm funksiyasi tasvir ma'lumotlariga va o'lchamlarga ko'rsatkich kutayotganini faraz qilish
      // Bu Wasm bilan ehtiyotkorlik bilan xotirani boshqarishni talab qiladi.
      // Umumiy shakl - Wasm-da xotira ajratish, ma'lumotlarni nusxalash, qayta ishlash, so'ngra qaytarib nusxalash.

      // Sodda bo'lishi uchun, imageProcessorModule.process xom tasvir baytlarini qabul qiladi
      // va qayta ishlangan baytlarni qaytaradi deb faraz qilamiz.
      // Haqiqiy senariyda siz SharedArrayBuffer yoki ArrayBuffer uzatasiz.

      const processedImageData = imageProcessorModule.process(imageData, width, height);

      self.postMessage({ status: 'success', processedImageData: processedImageData });
    } catch (error) {
      console.error('Wasm tasvirini qayta ishlashda xatolik:', error);
      self.postMessage({ status: 'error', message: error.message });
    }
  }
};

// Worker ishga tushganda Wasm-ni ishga tushirish
initializeWasm();

            

              
                Copy
              
            
          

            
// main.js

if (window.Worker) {
  const imageWorker = new Worker('./imageProcessorWorker.js', { type: 'module' });
  let isWasmReady = false;

  imageWorker.onmessage = function(event) {
    console.log('Tasvir workerining xabari:', event.data);
    if (event.data.status === 'wasm_ready') {
      isWasmReady = true;
      console.log('Tasvirni qayta ishlash tayyor.');
      // Endi siz qayta ishlash uchun tasvirlarni yuborishingiz mumkin
    } else if (event.data.status === 'success') {
      console.log('Tasvir muvaffaqiyatli qayta ishlandi.');
      // Qayta ishlangan tasvirni ko'rsatish (event.data.processedImageData)
    } else if (event.data.status === 'error') {
      console.error('Tasvirni qayta ishlashda xatolik:', event.data.message);
    }
  };

  // Misol: Qayta ishlash uchun tasvir faylingiz bor deb faraz qiling
  // Tasvir ma'lumotlarini olish (masalan, ArrayBuffer sifatida)
  fetch('./sample_image.png')
    .then(response => response.arrayBuffer())
    .then(arrayBuffer => {
      // Odatda bu yerda tasvir ma'lumotlarini, kenglikni, balandlikni ajratib olasiz
      // Bu misol uchun, ma'lumotlarni simulyatsiya qilamiz
      const dummyImageData = new Uint8Array(1000);
      const imageWidth = 10;
      const imageHeight = 10;

      // Ma'lumotlarni yuborishdan oldin Wasm moduli tayyor bo'lishini kutish
      const sendImage = () => {
        if (isWasmReady) {
          imageWorker.postMessage({
            type: 'process_image',
            imageData: dummyImageData, // ArrayBuffer yoki Uint8Array sifatida uzatish
            width: imageWidth,
            height: imageHeight
          });
        } else {
          setTimeout(sendImage, 100);
        }
      };
      sendImage();
    })
    .catch(error => {
      console.error('Tasvirni olishda xatolik:', error);
    });

} else {
  console.log('Web Workerlar qo\'llab-quvvatlanmaydi.');
}

            

              
                Copy
              
            
          

            
// workerPool.js

// Vaqt oladigan vazifani simulyatsiya qilish
function performComplexCalculation(input) {
  let result = 0;
  for (let i = 0; i < 1e7; i++) {
    result += Math.sin(input * i) * Math.cos(input / i);
  }
  return result;
}

self.onmessage = function(event) {
  const { taskInput, taskId } = event.data;
  console.log(`Worker ${self.name || ''} vazifa ${taskId}ni qayta ishlamoqda`);
  try {
    const result = performComplexCalculation(taskInput);
    self.postMessage({ status: 'success', result: result, taskId: taskId });
  } catch (error) {
    self.postMessage({ status: 'error', error: error.message, taskId: taskId });
  }
};

console.log('Worker hovuzi a\'zosi ishga tushirildi.');

            

              
                Copy
              
            
          

            
// main.js

const MAX_WORKERS = navigator.hardwareConcurrency || 4; // Mavjud yadrolardan foydalanish, standart 4
let workers = [];
let taskQueue = [];
let availableWorkers = [];

function initializeWorkerPool() {
  for (let i = 0; i < MAX_WORKERS; i++) {
    const worker = new Worker('./workerPool.js', { type: 'module' });
    worker.name = `Worker-${i}`;
    worker.isBusy = false;

    worker.onmessage = function(event) {
      console.log(`${worker.name}dan xabar:`, event.data);
      if (event.data.status === 'success' || event.data.status === 'error') {
        // Vazifa bajarildi, workerni bo'sh deb belgilash
        worker.isBusy = false;
        availableWorkers.push(worker);
        // Agar mavjud bo'lsa, keyingi vazifani qayta ishlash
        processNextTask();
      }
    };

    worker.onerror = function(error) {
      console.error(`${worker.name}da xatolik:`, error);
      worker.isBusy = false;
      availableWorkers.push(worker);
      processNextTask(); // Tiklanishga harakat qilish
    };

    workers.push(worker);
    availableWorkers.push(worker);
  }
  console.log(`Worker hovuzi ${MAX_WORKERS} ta worker bilan ishga tushirildi.`);
}

function addTask(taskInput) {
  taskQueue.push({ input: taskInput, id: Date.now() + Math.random() });
  processNextTask();
}

function processNextTask() {
  if (taskQueue.length === 0 || availableWorkers.length === 0) {
    return;
  }

  const worker = availableWorkers.shift();
  const task = taskQueue.shift();

  worker.isBusy = true;
  console.log(`Vazifa ${task.id} ${worker.name}ga tayinlanmoqda`);
  worker.postMessage({ taskInput: task.input, taskId: task.id });
}

// Asosiy ijro
if (window.Worker) {
  initializeWorkerPool();

  // Hovuzga vazifalar qo'shish
  for (let i = 0; i < 20; i++) {
    addTask(i * 0.1);
  }

} else {
  console.log('Web Workerlar qo\'llab-quvvatlanmaydi.');
}

            

              
                Copy