Worker Threads — CPU 집약 작업 분리

// main.js에서 Worker Thread 생성
const { Worker } = require('worker_threads');
const path = require('path');

ipcMain.handle('process:heavy', async (_event, data) => {
  return new Promise((resolve, reject) => {
    const worker = new Worker(path.join(__dirname, 'workers/heavy.js'), {
      workerData: data,
    });

    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0) {
        reject(new Error(`Worker 종료 코드: ${code}`));
      }
    });
  });
});

// workers/heavy.js
const { parentPort, workerData } = require('worker_threads');

// CPU 집약적 작업 수행
function processData(data) {
  // 예: 대용량 JSON 파싱, 이미지 변환, 암호화 등
  let result = 0;
  for (let i = 0; i < data.iterations; i++) {
    result += Math.sqrt(i);
  }
  return result;
}

const result = processData(workerData);
parentPort.postMessage(result);

class WorkerPool {
  constructor(workerFile, poolSize = 4) {
    this.workerFile = workerFile;
    this.poolSize = poolSize;
    this.workers = [];
    this.queue = [];

    for (let i = 0; i < poolSize; i++) {
      this.workers.push({ worker: this.createWorker(), busy: false });
    }
  }

  createWorker() {
    return new Worker(this.workerFile);
  }

  execute(data) {
    return new Promise((resolve, reject) => {
      const available = this.workers.find(w => !w.busy);
      if (available) {
        this.runTask(available, data, resolve, reject);
      } else {
        this.queue.push({ data, resolve, reject });
      }
    });
  }

  runTask(entry, data, resolve, reject) {
    entry.busy = true;
    entry.worker.postMessage(data);

    const onMessage = (result) => {
      entry.busy = false;
      entry.worker.removeListener('message', onMessage);
      resolve(result);
      this.processQueue();
    };

    entry.worker.on('message', onMessage);
    entry.worker.once('error', reject);
  }

  processQueue() {
    if (this.queue.length === 0) return;
    const available = this.workers.find(w => !w.busy);
    if (available) {
      const { data, resolve, reject } = this.queue.shift();
      this.runTask(available, data, resolve, reject);
    }
  }

  destroy() {
    this.workers.forEach(w => w.worker.terminate());
  }
}

// 사용
const pool = new WorkerPool('./workers/heavy.js', 4);
const result = await pool.execute({ iterations: 1000000 });

// main.js
const { utilityProcess } = require('electron');

const child = utilityProcess.fork(path.join(__dirname, 'services/indexer.js'));

child.postMessage({ type: 'index', directory: '/path/to/docs' });

child.on('message', (msg) => {
  if (msg.type === 'progress') {
    mainWindow.webContents.send('index:progress', msg.percent);
  }
  if (msg.type === 'done') {
    mainWindow.webContents.send('index:complete', msg.results);
  }
});

// services/indexer.js
process.parentPort.on('message', async (e) => {
  const { type, directory } = e.data;

  if (type === 'index') {
    const files = await scanDirectory(directory);
    for (let i = 0; i < files.length; i++) {
      await indexFile(files[i]);
      process.parentPort.postMessage({
        type: 'progress',
        percent: Math.round((i / files.length) * 100),
      });
    }
    process.parentPort.postMessage({ type: 'done', results: getIndex() });
  }
});

// renderer에서 사용
const worker = new Worker('./renderer-worker.js');
worker.postMessage({ type: 'sort', data: largeArray });

worker.onmessage = (e) => {
  const sorted = e.data;
  renderTable(sorted);
};