// worker.js - Worker執(zhí)行的代碼
self.onmessage = function(e) {
  const { taskId, payload } = e.data;
  
  // 執(zhí)行任務(wù)的邏輯
  const result = executeTask(payload);
  
  // 返回結(jié)果
  self.postMessage({
    taskId,
    result
  });
};

function executeTask(payload) {
  // 這里是工作線程的實際邏輯
  // 示例：簡單的計算任務(wù)
  if (payload.type === 'factorial') {
    return calculateFactorial(payload.number);
  } else if (payload.type === 'fibonacci') {
    return calculateFibonacci(payload.number);
  }
  return null;
}

function calculateFactorial(n) {
  if (n === 0 || n === 1) return 1;
  let result = 1;
  for (let i = 2; i <= n; i++) {
    result *= i;
  }
  return result;
}

function calculateFibonacci(n) {
  if (n <= 1) return n;
  
  let a = 0, b = 1;
  for (let i = 2; i <= n; i++) {
    const temp = a + b;
    a = b;
    b = temp;
  }
  return b;
}

// workerPool.js - Worker池的主要實現(xiàn)
class WorkerPool {
  constructor(workerPath, size) {
    this.workerPath = workerPath;
    this.size = size;
    this.workers = [];
    this.availableWorkers = [];
    this.taskQueue = [];
    this.taskCallbacks = new Map();
    this.taskIdCounter = 0;
    
    this.init();
  }
  
  init() {
    // 創(chuàng)建指定數(shù)量的worker
    for (let i = 0; i < this.size; i++) {
      const worker = new Worker(this.workerPath);
      
      worker.onmessage = (e) => {
        const { taskId, result } = e.data;
        
        // 調(diào)用對應(yīng)任務(wù)的回調(diào)
        const { resolve } = this.taskCallbacks.get(taskId);
        this.taskCallbacks.delete(taskId);
        
        // 將worker標(biāo)記為可用
        this.availableWorkers.push(worker);
        
        // 如果隊列中有等待的任務(wù)，則分配給空閑worker
        this.processQueue();
        
        // 完成任務(wù)的回調(diào)
        resolve(result);
      };
      
      worker.onerror = (error) => {
        console.error('Worker error:', error);
      };
      
      this.workers.push(worker);
      this.availableWorkers.push(worker);
    }
  }
  
  processQueue() {
    // 有等待的任務(wù)且有可用worker時執(zhí)行任務(wù)
    if (this.taskQueue.length > 0 && this.availableWorkers.length > 0) {
      const task = this.taskQueue.shift();
      const worker = this.availableWorkers.pop();
      
      worker.postMessage(task);
    }
  }
  
  executeTask(payload) {
    return new Promise((resolve, reject) => {
      const taskId = this.taskIdCounter++;
      
      // 創(chuàng)建任務(wù)對象
      const task = {
        taskId,
        payload
      };
      
      // 存儲任務(wù)回調(diào)
      this.taskCallbacks.set(taskId, { resolve, reject });
      
      // 如果有可用worker，直接分配任務(wù)
      if (this.availableWorkers.length > 0) {
        const worker = this.availableWorkers.pop();
        worker.postMessage(task);
      } else {
        // 否則將任務(wù)加入隊列
        this.taskQueue.push(task);
      }
    });
  }
  
  terminate() {
    // 終止所有worker
    this.workers.forEach(worker => worker.terminate());
    this.workers = [];
    this.availableWorkers = [];
    this.taskQueue = [];
    this.taskCallbacks.clear();
  }
}

// 使用示例
const pool = new WorkerPool('worker.js', 4); // 創(chuàng)建包含4個worker的池

// 使用worker池執(zhí)行任務(wù)
async function runTasks() {
  console.time('Tasks execution');
  
  // 并行執(zhí)行多個任務(wù)
  const results = await Promise.all([
    pool.executeTask({ type: 'factorial', number: 10 }),
    pool.executeTask({ type: 'fibonacci', number: 30 }),
    pool.executeTask({ type: 'factorial', number: 15 }),
    pool.executeTask({ type: 'fibonacci', number: 25 }),
    pool.executeTask({ type: 'factorial', number: 20 }),
    pool.executeTask({ type: 'fibonacci', number: 35 })
  ]);
  
  console.log('All task results:', results);
  console.timeEnd('Tasks execution');
}

runTasks().finally(() => {
  // 所有任務(wù)完成后，可以選擇終止worker池
  // pool.terminate();
});