콘텐츠 대표 이미지 - 자바스크립트 Web Workers: 멀티스레딩
JavaScript · 프로그램개발

자바스크립트 Web Workers: 멀티스레딩

싱글스레드의 한계를 뛰어넘는 JS 병렬처리의 모든 것 🚀

메인 스레드 (Main Thread) UI 렌더링 이벤트 처리 DOM 조작 ⚡ 무거운 연산? 싱글스레드 한계! Worker 1 🔢 수학 연산 Worker 2 📦 데이터 처리 Worker 3 🖼️ 이미지 처리 결과 수집 & 반환 postMessage() onmessage 이벤트 Web Workers = 병렬 처리로 메인 스레드 자유롭게! 🎉

🤔 잠깐, JS가 싱글스레드라고?

야 근데 자바스크립트가 싱글스레드라는 거 알아? ㅋㅋ

어 알지~ 그래서 무거운 연산 돌리면 화면이 그냥 멈춰버리잖아 ㅠㅠ

맞아ㅋㅋ 근데 Web Workers 쓰면 그거 해결된다고!

자바스크립트는 태생부터 싱글스레드(Single-threaded) 언어야. 브라우저 환경에서 JS는 딱 하나의 메인 스레드에서만 실행되는데, 이게 무슨 의미냐면... 한 번에 한 가지 일밖에 못 한다는 거임 ㅋㅋ

예를 들어서 엄청 복잡한 수학 계산을 JS로 돌리면? 그 계산이 끝날 때까지 UI가 완전히 얼어버려. 버튼 클릭도 안 되고, 스크롤도 안 되고, 애니메이션도 멈추고... 완전 UX 재앙이지 😱

💡 이벤트 루프가 있는데 왜 막히냐고?

JS에는 이벤트 루프(Event Loop)가 있어서 비동기 처리가 가능하긴 해. 근데 이건 I/O 작업(네트워크 요청, 파일 읽기 등)에는 효과적이지만, CPU 집약적인 연산(복잡한 계산, 대용량 데이터 파싱, 이미지 처리 등)에는 전혀 도움이 안 돼. 왜냐면 그 연산 자체가 메인 스레드를 점령해버리거든!

그래서 등장한 게 바로 Web Workers! 🎉 Web Workers는 메인 스레드와 별도의 스레드에서 JS 코드를 실행할 수 있게 해주는 브라우저 API야. 진짜 멀티스레딩이 가능해지는 거지!


🧵 Web Workers가 뭔데 정확히?

Web Workers는 W3C 표준으로 정의된 브라우저 API야. 2009년에 처음 스펙이 나왔고, 지금은 모든 모던 브라우저에서 지원해. 핵심 개념을 정리하면 이래:

1
별도 스레드에서 실행
Worker는 메인 스레드와 완전히 분리된 백그라운드 스레드에서 실행돼. 메인 스레드가 UI를 그리는 동안 Worker는 묵묵히 계산을 처리함 ㅋㅋ
2
DOM 접근 불가
Worker는 DOM, window 객체, document에 접근할 수 없어. 완전히 격리된 환경이야. 이게 단점처럼 보이지만 사실 스레드 안전성을 보장하는 핵심 설계야.
3
메시지 기반 통신
메인 스레드와 Worker는 postMessage()와 onmessage 이벤트를 통해서만 소통해. 데이터는 복사(structured clone)되거나 전송(transfer)돼.
4
독립적인 전역 스코프
Worker 안에서의 전역 객체는 self 또는 DedicatedWorkerGlobalScope야. window가 아님!

🔍 Worker에서 사용 가능한 것들

Worker 안에서도 꽤 많은 걸 쓸 수 있어:

XMLHttpRequest / fetch setTimeout / setInterval WebSockets IndexedDB importScripts() ES6 모듈 (type:module) Canvas API (OffscreenCanvas) Crypto API console.log Promise / async-await

🗂️ Web Workers 종류 총정리

Web Workers에는 여러 종류가 있어. 다 같은 Worker인 줄 알았지? ㅋㅋ 아님!

종류 특징 사용 사례
Dedicated Worker 하나의 스크립트에서만 사용 가능. 가장 기본적인 형태 단일 페이지의 무거운 연산
Shared Worker 여러 탭/창/iframe에서 공유 가능한 Worker 탭 간 데이터 공유, 공통 캐시
Service Worker 네트워크 프록시 역할. 오프라인 지원, 푸시 알림 PWA, 캐싱 전략, 백그라운드 동기화
Worklet 렌더링 파이프라인에 접근 가능한 경량 Worker CSS Houdini, Audio Worklet
💡 이 글에서 주로 다루는 건? 가장 많이 쓰이고 기본이 되는 Dedicated Worker를 중심으로 설명할게. Service Worker는 별도의 방대한 주제라서 나중에 따로 다루는 게 나아 ㅋㅋ
메인 스레드 ↔ Worker 통신 구조 메인 스레드 new Worker('worker.js') Worker 생성 worker.postMessage(data) 데이터 전송 worker.onmessage 결과 수신 📨 메시지 채널 Structured Clone 또는 Transferable Objects 방식 Worker 스레드 self.onmessage 데이터 수신 // 무거운 연산 처리 CPU 집약적 작업 self.postMessage(result) 결과 전송 두 스레드는 메모리를 공유하지 않아 → 안전한 병렬 처리! ⬆ postMessage ⬇ onmessage

💻 Web Workers 기본 사용법

자 이제 진짜 코드 보자! 생각보다 엄청 간단해 ㅋㅋ 겁먹지 마셈

📁 파일 구조

기본적으로 Worker는 별도의 JS 파일로 작성해:


project/
├── index.html
├── main.js        ← 메인 스레드 코드
└── worker.js      ← Worker 코드 (별도 파일!)

📝 main.js (메인 스레드)


// Worker 생성
const worker = new Worker('worker.js');

// Worker에게 데이터 전송
worker.postMessage({ 
  type: 'calculate',
  data: [1, 2, 3, 4, 5, ...] 
});

// Worker로부터 결과 수신
worker.onmessage = function(event) {
  console.log('결과 받았다!', event.data);
  // UI 업데이트 등 처리
};

// 에러 처리
worker.onerror = function(error) {
  console.error('Worker 에러:', error.message);
};

// Worker 종료 (필요할 때)
// worker.terminate();

📝 worker.js (Worker 스레드)


// Worker 내부에서 메시지 수신
self.onmessage = function(event) {
  const { type, data } = event.data;
  
  if (type === 'calculate') {
    // 무거운 연산 수행 (메인 스레드 안 막음!)
    const result = heavyCalculation(data);
    
    // 결과를 메인 스레드로 전송
    self.postMessage({ 
      type: 'result',
      result: result 
    });
  }
};

function heavyCalculation(data) {
  // 복잡한 연산...
  let sum = 0;
  for (let i = 0; i < data.length; i++) {
    sum += data[i] * data[i]; // 예시
  }
  return sum;
}
💡 addEventListener 방식도 OK! onmessage 대신 addEventListener('message', handler)를 써도 돼. 여러 핸들러를 등록할 수 있어서 더 유연함!

🎯 addEventListener 방식


// main.js
const worker = new Worker('worker.js');

worker.addEventListener('message', (event) => {
  console.log('수신:', event.data);
});

worker.addEventListener('error', (error) => {
  console.error('에러:', error);
});

// worker.js
self.addEventListener('message', (event) => {
  // 처리 로직
  self.postMessage('처리 완료!');
});

📦 데이터 전송 방식: 복사 vs 전송

Web Workers에서 데이터를 주고받는 방식이 두 가지야. 이걸 이해하는 게 성능 최적화에 진짜 중요해!

1️⃣ Structured Clone (구조적 복사)

기본 방식이야. 데이터를 복사해서 전달해. 원본은 그대로 유지되고 Worker에게 복사본이 전달됨.


// 복사 방식 (기본)
worker.postMessage({
  numbers: [1, 2, 3, 4, 5],
  config: { threshold: 100 }
});
// 원본 데이터는 메인 스레드에 그대로 남아있음
⚠️ 복사 방식의 단점 대용량 데이터(예: 100MB 이미지 버퍼)를 복사하면 메모리를 두 배로 쓰고, 복사 시간도 걸려. 이럴 때는 Transferable Objects를 써야 해!

2️⃣ Transferable Objects (소유권 이전)

데이터를 복사하지 않고 소유권 자체를 이전해. 전송 후 원본은 사용 불가(neutered)가 됨. 대신 엄청 빠름!


// 대용량 ArrayBuffer 생성
const buffer = new ArrayBuffer(1024 * 1024 * 100); // 100MB

// Transferable 방식으로 전송 (복사 없이 소유권 이전!)
worker.postMessage(
  { buffer: buffer },
  [buffer]  // ← 두 번째 인자에 transfer할 객체 배열
);

// 이제 메인 스레드에서 buffer는 사용 불가!
console.log(buffer.byteLength); // 0 (neutered!)
✅ Transferable Objects 지원 타입 ArrayBuffer MessagePort ReadableStream WritableStream TransformStream ImageBitmap OffscreenCanvas RTCDataChannel

3️⃣ SharedArrayBuffer (공유 메모리)

메인 스레드와 Worker가 같은 메모리를 공유하는 방식이야. 복사도 없고 소유권 이전도 없음. 진짜 공유!


// SharedArrayBuffer 생성
const sharedBuffer = new SharedArrayBuffer(1024);
const sharedArray = new Int32Array(sharedBuffer);

// Worker에게 공유 버퍼 전달
worker.postMessage({ sharedBuffer });

// Worker에서도 같은 메모리 접근 가능
// worker.js
self.onmessage = (e) => {
  const sharedArray = new Int32Array(e.data.sharedBuffer);
  sharedArray[0] = 42; // 메인 스레드에서도 즉시 반영됨!
};
⚠️ SharedArrayBuffer 보안 이슈! Spectre 취약점 때문에 SharedArrayBuffer를 사용하려면 페이지가 Cross-Origin Isolated 상태여야 해. HTTP 헤더에 Cross-Origin-Opener-Policy: same-origin과 Cross-Origin-Embedder-Policy: require-corp을 설정해야 함. 그리고 Atomics API와 함께 써야 경쟁 조건(race condition)을 방지할 수 있어!

🔥 실전 예제: 피보나치 수열 계산

이론은 충분히 봤으니까 진짜 실전 예제 보자! 피보나치 수열 계산은 Web Workers 예제의 클래식이야 ㅋㅋ

❌ Worker 없이 (UI 블로킹 발생)


// 메인 스레드에서 직접 실행 - UI 블로킹!
function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

document.getElementById('btn').addEventListener('click', () => {
  // 이 동안 UI가 완전히 멈춤 😱
  const result = fibonacci(45); // n=45면 수십 초 걸림
  document.getElementById('result').textContent = result;
});

✅ Worker 사용 (UI 자유로움)


// main.js
const worker = new Worker('fib-worker.js');

document.getElementById('btn').addEventListener('click', () => {
  // 로딩 표시 (UI는 계속 동작!)
  document.getElementById('status').textContent = '계산 중...';
  
  // Worker에게 계산 요청
  worker.postMessage({ n: 45 });
});

worker.onmessage = (event) => {
  document.getElementById('result').textContent = event.data.result;
  document.getElementById('status').textContent = '완료!';
};

// fib-worker.js
self.onmessage = (event) => {
  const { n } = event.data;
  
  function fibonacci(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
  }
  
  const result = fibonacci(n);
  self.postMessage({ result });
};
🎉 차이가 느껴지지? Worker 버전에서는 계산이 진행되는 동안에도 버튼 클릭, 스크롤, 애니메이션이 모두 정상 동작해! 메인 스레드가 자유롭거든. 이게 Web Workers의 핵심 가치야.

🖼️ 실전 예제: 이미지 필터 처리

이미지 처리는 Web Workers가 진짜 빛을 발하는 영역이야. 픽셀 데이터 조작은 엄청 CPU 집약적이거든!


// main.js - 이미지 그레이스케일 변환
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
const img = new Image();

img.onload = () => {
  canvas.width = img.width;
  canvas.height = img.height;
  ctx.drawImage(img, 0, 0);
  
  // 픽셀 데이터 추출
  const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
  
  // Worker 생성 및 데이터 전송
  const worker = new Worker('image-worker.js');
  
  // ArrayBuffer를 transfer로 전송 (복사 없이!)
  worker.postMessage(
    { 
      imageData: imageData.data.buffer,
      width: canvas.width,
      height: canvas.height
    },
    [imageData.data.buffer]  // Transferable!
  );
  
  worker.onmessage = (event) => {
    // 처리된 픽셀 데이터를 캔버스에 적용
    const processedBuffer = event.data.buffer;
    const processedData = new Uint8ClampedArray(processedBuffer);
    const newImageData = new ImageData(
      processedData, 
      canvas.width, 
      canvas.height
    );
    ctx.putImageData(newImageData, 0, 0);
    console.log('그레이스케일 변환 완료! 🎨');
  };
};

img.src = 'photo.jpg';

// image-worker.js
self.onmessage = (event) => {
  const { imageData, width, height } = event.data;
  const pixels = new Uint8ClampedArray(imageData);
  
  // 그레이스케일 변환 (픽셀 하나하나 처리)
  for (let i = 0; i < pixels.length; i += 4) {
    const r = pixels[i];
    const g = pixels[i + 1];
    const b = pixels[i + 2];
    // 가중 평균으로 그레이스케일 계산
    const gray = 0.299 * r + 0.587 * g + 0.114 * b;
    pixels[i] = gray;     // R
    pixels[i + 1] = gray; // G
    pixels[i + 2] = gray; // B
    // pixels[i + 3] = alpha (변경 없음)
  }
  
  // 처리된 버퍼를 transfer로 반환
  self.postMessage(
    { buffer: pixels.buffer },
    [pixels.buffer]
  );
};
💡 OffscreenCanvas로 더 강력하게! 최신 브라우저에서는 OffscreenCanvas를 Worker에 transfer해서 Worker 내부에서 직접 캔버스 렌더링도 가능해. 메인 스레드 부담을 더 줄일 수 있음!

🏊 Worker Pool 패턴

Worker를 매번 생성하고 종료하면 오버헤드가 커. 그래서 실무에서는 Worker Pool 패턴을 많이 써. 미리 Worker를 여러 개 만들어두고 재사용하는 거야!


// WorkerPool 클래스 구현
class WorkerPool {
  constructor(workerScript, poolSize) {
    this.workers = [];
    this.queue = [];
    this.activeWorkers = new Map();
    
    // 풀 크기만큼 Worker 미리 생성
    for (let i = 0; i < poolSize; i++) {
      const worker = new Worker(workerScript);
      worker.id = i;
      worker.busy = false;
      
      worker.onmessage = (event) => {
        const resolve = this.activeWorkers.get(worker.id);
        if (resolve) {
          resolve(event.data);
          this.activeWorkers.delete(worker.id);
        }
        worker.busy = false;
        this._processQueue(); // 대기 중인 작업 처리
      };
      
      this.workers.push(worker);
    }
  }
  
  // 작업 실행 (Promise 반환)
  run(data) {
    return new Promise((resolve, reject) => {
      const freeWorker = this.workers.find(w => !w.busy);
      
      if (freeWorker) {
        this._assignWork(freeWorker, data, resolve);
      } else {
        // 모든 Worker가 바쁘면 큐에 추가
        this.queue.push({ data, resolve, reject });
      }
    });
  }
  
  _assignWork(worker, data, resolve) {
    worker.busy = true;
    this.activeWorkers.set(worker.id, resolve);
    worker.postMessage(data);
  }
  
  _processQueue() {
    if (this.queue.length === 0) return;
    const freeWorker = this.workers.find(w => !w.busy);
    if (!freeWorker) return;
    
    const { data, resolve } = this.queue.shift();
    this._assignWork(freeWorker, data, resolve);
  }
  
  // 모든 Worker 종료
  terminate() {
    this.workers.forEach(w => w.terminate());
  }
}

// 사용 예시
const pool = new WorkerPool('heavy-worker.js', 4); // 4개 Worker 풀

// 여러 작업을 병렬로 처리
const tasks = [100, 200, 300, 400, 500];
const promises = tasks.map(n => pool.run({ n }));

Promise.all(promises).then(results => {
  console.log('모든 작업 완료!', results);
  pool.terminate();
});
🎯 Worker Pool의 장점 Worker 생성/종료 오버헤드 제거, 메모리 효율적 관리, 동시 실행 수 제어 가능, 작업 큐잉으로 순서 보장 가능!
Worker Pool 패턴 동작 방식 작업 큐 작업 1 작업 2 작업 3 작업 4 (대기) 작업 5 (대기) 순서대로 배분 Worker 1 🟢 작업 1 처리 중... CPU 사용 중 Worker 2 🟢 작업 2 처리 중... CPU 사용 중 Worker 3 🟢 작업 3 처리 중... CPU 사용 중 결과 수집 ✅ 결과 1 완료 ✅ 결과 2 완료 ✅ 결과 3 완료 Promise.all() 처리 메인 스레드 UI 업데이트 결과 표시 🎉 3개 Worker가 동시에 작업 처리 → 3배 빠른 처리 속도!

📌 Inline Worker: 파일 없이 Worker 만들기

Worker를 별도 파일 없이 만들 수 있어! Blob URL을 이용하는 방법이야. 번들러 없이 간단하게 쓸 때 유용함 ㅋㅋ


// Blob을 이용한 Inline Worker
const workerCode = `
  self.onmessage = function(event) {
    const { n } = event.data;
    let result = 0;
    for (let i = 0; i < n; i++) {
      result += i;
    }
    self.postMessage({ result });
  };
`;

// Blob으로 Worker 코드 감싸기
const blob = new Blob([workerCode], { type: 'application/javascript' });
const workerUrl = URL.createObjectURL(blob);
const worker = new Worker(workerUrl);

// 사용 후 URL 해제 (메모리 관리)
URL.revokeObjectURL(workerUrl);

worker.postMessage({ n: 1000000 });
worker.onmessage = (e) => {
  console.log('합계:', e.data.result);
};

🔧 ES6 모듈 Worker (type: module)

최신 브라우저에서는 Worker에서도 ES6 모듈을 쓸 수 있어!


// type: 'module' 옵션으로 모듈 Worker 생성
const worker = new Worker('module-worker.js', { type: 'module' });

// module-worker.js
import { heavyCalc } from './utils.js'; // import 가능!

self.onmessage = async (event) => {
  const result = await heavyCalc(event.data);
  self.postMessage(result);
};
💡 Vite/Webpack에서 Worker 사용 모던 번들러에서는 더 편하게 쓸 수 있어!
Vite: new Worker(new URL('./worker.js', import.meta.url))
Webpack: new Worker(new URL('./worker.js', import.meta.url), { type: 'module' })

🔗 Comlink: Worker를 더 쉽게!

postMessage/onmessage 방식이 좀 번거롭다고 느껴지면? Google이 만든 Comlink 라이브러리를 써봐! Worker를 마치 일반 함수처럼 호출할 수 있게 해줌 ㅋㅋ 진짜 편해


// npm install comlink
import * as Comlink from 'comlink';

// worker.js
const api = {
  fibonacci(n) {
    if (n <= 1) return n;
    return api.fibonacci(n - 1) + api.fibonacci(n - 2);
  },
  
  async processData(data) {
    // 비동기 작업도 OK
    return data.map(x => x * 2);
  }
};

Comlink.expose(api);

// main.js
import * as Comlink from 'comlink';

const worker = new Worker('worker.js', { type: 'module' });
const api = Comlink.wrap(worker);

// 마치 일반 함수처럼 호출! (실제론 Worker에서 실행)
const result = await api.fibonacci(40);
console.log(result); // 102334155

const processed = await api.processData([1, 2, 3, 4, 5]);
console.log(processed); // [2, 4, 6, 8, 10]
✨ Comlink의 마법 내부적으로 Proxy와 MessageChannel을 활용해서 Worker 함수 호출을 Promise로 래핑해줘. postMessage 보일러플레이트 코드가 사라지고 코드가 훨씬 깔끔해짐!

⚡ 성능 최적화 & 주의사항

Web Workers가 만능은 아니야! 잘못 쓰면 오히려 성능이 떨어질 수도 있어. 주의사항 체크해봐 ㅋㅋ

🚫 Worker를 쓰면 안 되는 경우

✗
가벼운 연산
Worker 생성 자체에 수십~수백ms 오버헤드가 있어. 1ms짜리 계산을 Worker로 보내면 오히려 느려짐!
✗
DOM 조작이 필요한 작업
Worker는 DOM에 접근 못 해. DOM 조작이 주 목적이라면 Worker는 의미 없음.
✗
빈번한 소규모 데이터 교환
postMessage 자체도 비용이 있어. 작은 데이터를 수천 번 주고받으면 오버헤드가 쌓임.

✅ Worker를 써야 하는 경우

✓
CPU 집약적 연산
암호화/복호화, 압축/해제, 복잡한 수학 계산, 머신러닝 추론 등
✓
대용량 데이터 처리
수백만 개 배열 정렬, 대용량 JSON 파싱, 이미지/오디오 처리
✓
실시간 UI 반응성이 중요한 앱
게임, 데이터 시각화, 실시간 편집기 등에서 백그라운드 처리

📊 Worker 생성 비용 측정


// Worker 생성 시간 측정
const start = performance.now();
const worker = new Worker('worker.js');

worker.onmessage = () => {
  const end = performance.now();
  console.log(`Worker 준비 시간: ${end - start}ms`);
  // 보통 10ms ~ 100ms 정도 걸림
};

worker.postMessage('ping'); // 즉시 응답 요청

// worker.js
self.onmessage = () => self.postMessage('pong');
⚠️ 메모리 누수 주의! Worker를 사용 후 반드시 worker.terminate()를 호출해야 해. 안 그러면 Worker 스레드가 계속 살아있어서 메모리를 잡아먹음! 컴포넌트 언마운트 시 정리하는 습관을 들이자.

⚛️ React/Vue에서 Web Workers 사용하기

실무에서는 React나 Vue 같은 프레임워크를 쓰잖아? 거기서 Worker 쓰는 방법도 알아보자!

⚛️ React에서 Worker 사용 (useWorker 훅)


// useWorker.js - 커스텀 훅
import { useEffect, useRef, useState } from 'react';

function useWorker(workerScript) {
  const workerRef = useRef(null);
  const [result, setResult] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);
  
  useEffect(() => {
    // Worker 생성
    workerRef.current = new Worker(
      new URL(workerScript, import.meta.url)
    );
    
    workerRef.current.onmessage = (event) => {
      setResult(event.data);
      setLoading(false);
    };
    
    workerRef.current.onerror = (err) => {
      setError(err.message);
      setLoading(false);
    };
    
    // 컴포넌트 언마운트 시 Worker 정리!
    return () => {
      workerRef.current?.terminate();
    };
  }, [workerScript]);
  
  const runWorker = (data) => {
    setLoading(true);
    setError(null);
    workerRef.current?.postMessage(data);
  };
  
  return { result, loading, error, runWorker };
}

// 컴포넌트에서 사용
function HeavyCalcComponent() {
  const { result, loading, runWorker } = useWorker('./calc-worker.js');
  
  return (
    <div>
      <button onClick={() => runWorker({ n: 45 })} disabled={loading}>
        {loading ? '계산 중... ⏳' : '피보나치 계산 시작!'}
      </button>
      {result && <p>결과: {result.value}</p>}
    </div>
  );
}

💚 Vue 3에서 Worker 사용


// useWorker.ts (Vue 3 Composable)
import { ref, onUnmounted } from 'vue';

export function useWorker(workerUrl: string) {
  const result = ref(null);
  const loading = ref(false);
  
  const worker = new Worker(
    new URL(workerUrl, import.meta.url),
    { type: 'module' }
  );
  
  worker.onmessage = (event) => {
    result.value = event.data;
    loading.value = false;
  };
  
  // 컴포넌트 언마운트 시 자동 정리
  onUnmounted(() => {
    worker.terminate();
  });
  
  const run = (data: any) => {
    loading.value = true;
    worker.postMessage(data);
  };
  
  return { result, loading, run };
}

// 컴포넌트에서 사용
// <script setup>
// const { result, loading, run } = useWorker('./heavy-worker.js');
// </script>
💡 useWebWorkerFn 라이브러리 @koale/useworker (React) 또는 @vueuse/core의 useWebWorkerFn을 쓰면 일반 함수를 Worker로 자동 변환해줘. 진짜 편함 ㅋㅋ

🌍 실제 서비스에서의 Web Workers 활용

Web Workers가 실제로 어떤 서비스에서 쓰이는지 알아보자. 생각보다 엄청 많은 곳에서 쓰고 있어!

서비스/분야 Web Workers 활용
🎨 Figma WebAssembly + Worker로 렌더링 엔진 실행. 복잡한 벡터 계산을 백그라운드에서 처리
📊 Google Sheets 스프레드시트 수식 계산, 대용량 데이터 처리를 Worker로 분리
🎵 Spotify Web 오디오 디코딩, 파형 시각화 데이터 계산
🗺️ Google Maps 지도 타일 처리, 경로 계산 알고리즘
💻 VS Code Web 언어 서버 프로토콜(LSP), 코드 분석, 자동완성
🤖 TensorFlow.js 머신러닝 모델 추론을 Worker에서 실행
📸 사진 편집 앱 필터 적용, 이미지 리사이징, 포맷 변환
🎯 재능넷에서도 활용 가능! 재능넷처럼 다양한 재능을 거래하는 플랫폼에서도 Web Workers는 유용해. 예를 들어 포트폴리오 이미지 처리, 대용량 파일 업로드 전 압축, 실시간 검색 필터링 등에 활용할 수 있거든!

🐛 Web Workers 디버깅 방법

Worker 디버깅이 좀 까다롭긴 한데, 방법을 알면 별거 아니야 ㅋㅋ

🔍 Chrome DevTools에서 Worker 디버깅

1
Sources 탭 열기
F12 → Sources 탭 → 왼쪽 패널에서 "Threads" 섹션 확인. Worker 스레드가 별도로 표시됨!
2
Worker 파일에 브레이크포인트 설정
Worker 스레드를 클릭하면 해당 Worker의 소스 파일에 접근 가능. 일반 JS처럼 브레이크포인트 설정 가능!
3
console.log 활용
Worker 내부의 console.log는 메인 스레드의 콘솔에 출력돼. 어떤 Worker에서 출력됐는지도 표시됨!

// Worker 내부 에러 처리 패턴
self.onmessage = (event) => {
  try {
    const result = riskyOperation(event.data);
    self.postMessage({ success: true, result });
  } catch (error) {
    // 에러를 메인 스레드로 전달
    self.postMessage({ 
      success: false, 
      error: {
        message: error.message,
        stack: error.stack
      }
    });
  }
};

// main.js에서 에러 처리
worker.onmessage = (event) => {
  if (!event.data.success) {
    console.error('Worker 에러:', event.data.error);
    return;
  }
  // 정상 처리
  handleResult(event.data.result);
};

🌐 브라우저 지원 현황

Web Workers 브라우저 지원은 이미 매우 광범위해. 걱정 안 해도 됨 ㅋㅋ

브라우저 Dedicated Worker Shared Worker Service Worker
Chrome ✅ v4+ ✅ v4+ ✅ v40+
Firefox ✅ v3.5+ ✅ v29+ ✅ v44+
Safari ✅ v4+ ⚠️ v5+ (제한적) ✅ v11.1+
Edge ✅ v12+ ✅ v79+ ✅ v17+
iOS Safari ✅ v5+ ⚠️ 제한적 ✅ v11.3+

// Worker 지원 여부 확인
if (typeof Worker !== 'undefined') {
  // Worker 사용 가능!
  const worker = new Worker('worker.js');
} else {
  // 폴백: 메인 스레드에서 직접 실행
  console.warn('Web Workers를 지원하지 않는 브라우저입니다.');
  // 동기적으로 처리하거나 다른 방법 사용
}

🔬 심화: Atomics API로 동기화하기

SharedArrayBuffer를 여러 Worker가 동시에 접근하면 경쟁 조건(Race Condition)이 발생할 수 있어. 이걸 해결하는 게 Atomics API야!


// SharedArrayBuffer + Atomics 예제
const sharedBuffer = new SharedArrayBuffer(4); // 4바이트
const sharedInt = new Int32Array(sharedBuffer);

// Worker 1에서
Atomics.add(sharedInt, 0, 1); // 원자적 덧셈 (스레드 안전!)

// Worker 2에서 동시에 실행해도 안전
Atomics.add(sharedInt, 0, 1);

// 결과는 항상 2 (경쟁 조건 없음!)
console.log(Atomics.load(sharedInt, 0)); // 2

// wait/notify로 스레드 동기화
// Worker에서 대기
Atomics.wait(sharedInt, 0, 0); // 인덱스 0의 값이 0이면 대기

// 메인 스레드에서 깨우기
Atomics.notify(sharedInt, 0, 1); // 대기 중인 Worker 1개 깨우기
⚠️ Atomics.wait()는 메인 스레드에서 사용 불가! Atomics.wait()는 스레드를 블로킹하기 때문에 메인 스레드에서 호출하면 에러가 발생해. Worker 스레드에서만 사용 가능. 메인 스레드에서는 Atomics.waitAsync()를 써야 해!

🔒 Mutex 구현 예제


// SharedArrayBuffer로 Mutex 구현
class Mutex {
  constructor() {
    this._lock = new Int32Array(new SharedArrayBuffer(4));
  }
  
  lock() {
    // CAS(Compare-And-Swap)로 락 획득
    while (Atomics.compareExchange(this._lock, 0, 0, 1) !== 0) {
      // 락이 해제될 때까지 대기
      Atomics.wait(this._lock, 0, 1);
    }
  }
  
  unlock() {
    Atomics.store(this._lock, 0, 0);
    Atomics.notify(this._lock, 0, 1);
  }
}

// Worker에서 사용
const mutex = new Mutex();
mutex.lock();
// 임계 구역 (Critical Section)
sharedData[0] += 1;
mutex.unlock();

📈 성능 벤치마크: 얼마나 빨라지나?

실제로 얼마나 빨라지는지 궁금하지? ㅋㅋ 간단한 벤치마크 코드로 확인해보자!


// 성능 측정 유틸리티
async function benchmark() {
  const DATA_SIZE = 10_000_000; // 천만 개
  const data = new Float64Array(DATA_SIZE).fill(1.5);
  
  // 1. 메인 스레드에서 처리
  console.time('메인 스레드');
  let sum = 0;
  for (let i = 0; i < data.length; i++) {
    sum += Math.sqrt(data[i]);
  }
  console.timeEnd('메인 스레드');
  // 결과: 약 150ms (UI 블로킹!)
  
  // 2. 4개 Worker로 병렬 처리
  console.time('Worker 4개 병렬');
  const chunkSize = DATA_SIZE / 4;
  const workers = Array.from({ length: 4 }, () => 
    new Worker('calc-worker.js')
  );
  
  const results = await Promise.all(
    workers.map((worker, i) => {
      const chunk = data.slice(i * chunkSize, (i + 1) * chunkSize);
      return new Promise(resolve => {
        worker.onmessage = e => resolve(e.data.sum);
        worker.postMessage({ chunk }, [chunk.buffer]);
      });
    })
  );
  
  const totalSum = results.reduce((a, b) => a + b, 0);
  console.timeEnd('Worker 4개 병렬');
  // 결과: 약 45ms (약 3.3배 빠름! UI도 자유로움!)
  
  workers.forEach(w => w.terminate());
}
📊 실제 성능 향상 수치 (참고) CPU 코어 수에 따라 다르지만, 일반적으로:
• 2코어 환경: 약 1.5~1.8배 향상
• 4코어 환경: 약 2.5~3.5배 향상
• 8코어 환경: 약 4~6배 향상
(Worker 생성 오버헤드, 데이터 전송 비용 포함한 실제 수치)

🚀 최신 트렌드: WebAssembly + Workers

요즘 가장 핫한 조합이 바로 WebAssembly(WASM) + Web Workers야! WASM은 C/C++/Rust 같은 언어로 작성된 코드를 브라우저에서 네이티브에 가까운 속도로 실행할 수 있게 해줘. 여기에 Workers까지 더하면 진짜 괴물 성능이 나옴 ㅋㅋ


// WebAssembly + Worker 조합
// worker.js
let wasmInstance = null;

async function initWasm() {
  const response = await fetch('heavy-calc.wasm');
  const buffer = await response.arrayBuffer();
  const { instance } = await WebAssembly.instantiate(buffer);
  wasmInstance = instance;
}

self.onmessage = async (event) => {
  if (!wasmInstance) {
    await initWasm();
  }
  
  const { data } = event.data;
  
  // WASM 함수 호출 (C/Rust로 작성된 초고속 연산!)
  const result = wasmInstance.exports.processData(data);
  
  self.postMessage({ result });
};
🔥 실제 사용 사례 • Figma: Rust → WASM + Worker로 렌더링 엔진 구현
• Google Earth Web: C++ → WASM + Worker로 3D 지구 렌더링
• AutoCAD Web: 30년된 C++ 코드를 WASM으로 포팅 후 Worker에서 실행
• TensorFlow.js: WASM 백엔드를 Worker에서 실행해 ML 추론 가속화

재능넷 같은 플랫폼에서도 이미지 처리나 파일 변환 기능을 구현할 때 WASM + Worker 조합을 활용하면 사용자 경험을 크게 향상시킬 수 있어!

Web Workers 핵심 정리 🧵 기본 개념 별도 스레드에서 실행 DOM 접근 불가 메시지 기반 통신 독립적 전역 스코프 self = 전역 객체 📦 데이터 전송 Structured Clone (복사) Transferable (소유권 이전) SharedArrayBuffer (공유) Atomics (동기화) postMessage / onmessage 🗂️ Worker 종류 Dedicated Worker (기본) Shared Worker (공유) Service Worker (PWA) Worklet (렌더링) Module Worker (ES6) 🔥 활용 사례 이미지/오디오 처리 암호화/복호화 대용량 데이터 파싱 ML 모델 추론 실시간 계산 ⚡ 성능 최적화 팁 Worker Pool로 재사용 → 생성 오버헤드 제거 대용량 데이터는 Transferable 사용 사용 후 반드시 terminate() 호출 가벼운 연산은 Worker 쓰지 말 것! 🛠️ 유용한 도구들 Comlink: RPC 스타일 Worker 통신 useWebWorkerFn: React/Vue 훅 Vite/Webpack: 번들러 Worker 지원 WASM + Worker: 최강 성능 조합 Web Workers = 브라우저에서 진짜 멀티스레딩! 🚀

🎯 마무리: 언제 써야 할까?

자 이제 Web Workers에 대해 꽤 깊이 알게 됐지? ㅋㅋ 마지막으로 핵심만 정리해줄게!

근데 솔직히 언제 써야 하는 거야? 기준이 뭐야?

간단해! 메인 스레드에서 실행했을 때 16ms(60fps 기준) 이상 걸리는 작업이면 Worker 고려해봐!

오 그 기준 좋다ㅋㅋ 16ms면 한 프레임이잖아!

맞아! 그 이상 걸리면 화면이 버벅이거든. Worker로 빼면 UI는 계속 60fps 유지 가능!

📋 Web Workers 도입 체크리스트

✓
해당 작업이 16ms 이상 걸리는가?
✓
DOM 조작 없이 순수 계산/데이터 처리인가?
✓
작업 중 UI 반응성이 중요한가?
✓
데이터 전송 비용보다 연산 비용이 훨씬 큰가?
✓
Worker 생성 오버헤드를 감당할 만큼 작업이 무거운가?

위 항목 중 3개 이상 해당되면 Web Workers 도입을 강력 추천!

Web Workers는 자바스크립트의 싱글스레드 한계를 극복하는 강력한 도구야. 처음엔 postMessage/onmessage 방식이 좀 낯설 수 있지만, Comlink 같은 라이브러리를 쓰면 훨씬 편해지고, React/Vue 훅으로 추상화하면 더욱 깔끔하게 쓸 수 있어.

특히 요즘처럼 브라우저에서 ML 추론, 실시간 영상 처리, 복잡한 데이터 시각화 같은 무거운 작업들이 늘어나는 시대에 Web Workers는 선택이 아닌 필수가 되어가고 있어. 지금 당장 프로젝트에서 병목이 되는 연산을 찾아서 Worker로 분리해봐! 🚀

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.