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

자바스크립트 Web Workers: 멀티스레딩
싱글스레드의 한계를 뛰어넘는 JS 병렬처리의 모든 것 🚀
🤔 잠깐, JS가 싱글스레드라고?
자바스크립트는 태생부터 싱글스레드(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년에 처음 스펙이 나왔고, 지금은 모든 모던 브라우저에서 지원해. 핵심 개념을 정리하면 이래:
Worker는 메인 스레드와 완전히 분리된 백그라운드 스레드에서 실행돼. 메인 스레드가 UI를 그리는 동안 Worker는 묵묵히 계산을 처리함 ㅋㅋ
Worker는 DOM, window 객체, document에 접근할 수 없어. 완전히 격리된 환경이야. 이게 단점처럼 보이지만 사실 스레드 안전성을 보장하는 핵심 설계야.
메인 스레드와 Worker는 postMessage()와 onmessage 이벤트를 통해서만 소통해. 데이터는 복사(structured clone)되거나 전송(transfer)돼.
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 |
💻 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 방식
// 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 }
});
// 원본 데이터는 메인 스레드에 그대로 남아있음
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!)
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; // 메인 스레드에서도 즉시 반영됨!
};
🔥 실전 예제: 피보나치 수열 계산
이론은 충분히 봤으니까 진짜 실전 예제 보자! 피보나치 수열 계산은 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 });
};
🖼️ 실전 예제: 이미지 필터 처리
이미지 처리는 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]
);
};
🏊 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();
});
📌 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: 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]
⚡ 성능 최적화 & 주의사항
Web Workers가 만능은 아니야! 잘못 쓰면 오히려 성능이 떨어질 수도 있어. 주의사항 체크해봐 ㅋㅋ
🚫 Worker를 쓰면 안 되는 경우
Worker 생성 자체에 수십~수백ms 오버헤드가 있어. 1ms짜리 계산을 Worker로 보내면 오히려 느려짐!
Worker는 DOM에 접근 못 해. DOM 조작이 주 목적이라면 Worker는 의미 없음.
postMessage 자체도 비용이 있어. 작은 데이터를 수천 번 주고받으면 오버헤드가 쌓임.
✅ Worker를 써야 하는 경우
암호화/복호화, 압축/해제, 복잡한 수학 계산, 머신러닝 추론 등
수백만 개 배열 정렬, 대용량 JSON 파싱, 이미지/오디오 처리
게임, 데이터 시각화, 실시간 편집기 등에서 백그라운드 처리
📊 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');
⚛️ 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>
🌍 실제 서비스에서의 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 디버깅 방법
Worker 디버깅이 좀 까다롭긴 한데, 방법을 알면 별거 아니야 ㅋㅋ
🔍 Chrome DevTools에서 Worker 디버깅
F12 → Sources 탭 → 왼쪽 패널에서 "Threads" 섹션 확인. Worker 스레드가 별도로 표시됨!
Worker 스레드를 클릭하면 해당 Worker의 소스 파일에 접근 가능. 일반 JS처럼 브레이크포인트 설정 가능!
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개 깨우기
🔒 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());
}
• 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 });
};
• Google Earth Web: C++ → WASM + Worker로 3D 지구 렌더링
• AutoCAD Web: 30년된 C++ 코드를 WASM으로 포팅 후 Worker에서 실행
• TensorFlow.js: WASM 백엔드를 Worker에서 실행해 ML 추론 가속화
재능넷 같은 플랫폼에서도 이미지 처리나 파일 변환 기능을 구현할 때 WASM + Worker 조합을 활용하면 사용자 경험을 크게 향상시킬 수 있어!
🎯 마무리: 언제 써야 할까?
자 이제 Web Workers에 대해 꽤 깊이 알게 됐지? ㅋㅋ 마지막으로 핵심만 정리해줄게!
📋 Web Workers 도입 체크리스트
위 항목 중 3개 이상 해당되면 Web Workers 도입을 강력 추천!
Web Workers는 자바스크립트의 싱글스레드 한계를 극복하는 강력한 도구야. 처음엔 postMessage/onmessage 방식이 좀 낯설 수 있지만, Comlink 같은 라이브러리를 쓰면 훨씬 편해지고, React/Vue 훅으로 추상화하면 더욱 깔끔하게 쓸 수 있어.
특히 요즘처럼 브라우저에서 ML 추론, 실시간 영상 처리, 복잡한 데이터 시각화 같은 무거운 작업들이 늘어나는 시대에 Web Workers는 선택이 아닌 필수가 되어가고 있어. 지금 당장 프로젝트에서 병목이 되는 연산을 찾아서 Worker로 분리해봐! 🚀
관련 키워드
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.