Ver3.0 ⚡ 웹 워커와 멀티스레딩으로 메인 스레드 블로킹 완벽 해결하기

⚡ 웹 워커와 멀티스레딩으로 메인 스레드 블로킹 완벽 해결하기
브라우저를 멈추지 않는 똑똑한 개발 전략 🚀
안녕! 혹시 웹사이트 쓰다가 갑자기 화면이 얼어붙은 경험 있어? 🥶
버튼을 눌러도 반응이 없고, 스크롤도 안 되고... 이게 바로 메인 스레드 블로킹 현상이야.
오늘은 이 짜증나는 문제를 웹 워커(Web Worker)와 멀티스레딩 기법으로 깔끔하게 해결하는 방법을 알려줄게! 😎
프로그래밍 초보자도 이해할 수 있게 친구한테 설명하듯이 쉽게 풀어볼게~
🎯 메인 스레드가 뭔데? 왜 블로킹되는 거야?
먼저 기본부터 알아보자! 브라우저는 기본적으로 싱글 스레드로 동작해.
쉽게 말하면, 한 명의 일꾼이 모든 일을 처리하는 거지. 🏃♂️
이 일꾼(메인 스레드)이 하는 일들을 보면:
✅ JavaScript 코드 실행
✅ HTML/CSS 렌더링
✅ 사용자 이벤트 처리 (클릭, 스크롤 등)
✅ DOM 조작
✅ 애니메이션 처리
문제는 이 일꾼이 무거운 작업을 만나면 다른 일을 전혀 못한다는 거야! 😱
예를 들어, 엄청 큰 데이터를 계산하거나 복잡한 이미지 처리를 하는 동안에는
사용자가 버튼을 눌러도, 스크롤을 해도 아무 반응이 없어.
이게 바로 메인 스레드 블로킹이야!
🎪 웹 워커(Web Worker)가 뭐야?
웹 워커는 쉽게 말해서 추가 일꾼을 고용하는 것이야! 🧑💼
메인 스레드가 혼자 일하느라 힘들면, 웹 워커라는 보조 일꾼을 불러서
무거운 작업을 맡기는 거지.
이렇게 하면 메인 스레드는 UI 관련 일에만 집중할 수 있어서
사용자는 항상 부드러운 경험을 할 수 있어! ✨
💡 웹 워커의 핵심 특징
🔹 백그라운드에서 독립적으로 실행
🔹 메인 스레드를 블로킹하지 않음
🔹 CPU 집약적인 작업에 최적화
🔹 메시지 기반으로 메인 스레드와 통신
🔹 DOM에 직접 접근 불가 (안전성 확보)
🛠️ 웹 워커 기본 사용법 - 실전 코드!
자, 이제 실제로 어떻게 쓰는지 코드로 알아보자! 😊
생각보다 엄청 간단해. 크게 3단계만 기억하면 돼:
먼저 워커가 실행할 작업을 별도 파일로 만들어야 해:
// worker.js
// 워커 스레드에서 실행될 코드
// 메시지를 받으면 실행되는 이벤트 리스너
self.addEventListener('message', function(e) {
const data = e.data;
// 무거운 계산 작업 예시
let result = 0;
for (let i = 0; i < data.count; i++) {
result += Math.sqrt(i) * Math.random();
}
// 계산 결과를 메인 스레드로 전송
self.postMessage({
result: result,
message: '계산 완료!'
});
});
// 에러 처리
self.addEventListener('error', function(e) {
console.error('워커 에러:', e.message);
});
// main.js
// 메인 스레드 코드
// 워커 생성
const worker = new Worker('worker.js');
// 워커로부터 메시지 받기
worker.addEventListener('message', function(e) {
console.log('워커로부터 받은 결과:', e.data.result);
console.log('메시지:', e.data.message);
// UI 업데이트
document.getElementById('result').textContent = e.data.result;
});
// 워커에게 작업 요청하기
worker.postMessage({
count: 10000000 // 천만 번 계산 요청
});
// 워커 종료하기 (작업이 끝나면)
// worker.terminate();
실제로 많이 쓰이는 예제를 하나 더 볼까? 📸
이미지에 필터를 적용하는 건 엄청 무거운 작업이야.
픽셀 하나하나를 다 계산해야 하거든!
// imageWorker.js
self.addEventListener('message', function(e) {
const imageData = e.data.imageData;
const pixels = imageData.data;
// 그레이스케일 필터 적용
for (let i = 0; i < pixels.length; i += 4) {
const gray = pixels[i] * 0.299 +
pixels[i + 1] * 0.587 +
pixels[i + 2] * 0.114;
pixels[i] = gray; // Red
pixels[i + 1] = gray; // Green
pixels[i + 2] = gray; // Blue
// pixels[i + 3]은 Alpha (투명도)
}
// 처리된 이미지 데이터 반환
self.postMessage({ imageData: imageData });
});
// main.js
const canvas = document.getElementById('myCanvas');
const ctx = canvas.getContext('2d');
const imageWorker = new Worker('imageWorker.js');
imageWorker.addEventListener('message', function(e) {
// 처리된 이미지를 캔버스에 그리기
ctx.putImageData(e.data.imageData, 0, 0);
console.log('이미지 필터 적용 완료! 🎨');
});
// 이미지 데이터 가져오기
const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
// 워커에게 처리 요청
imageWorker.postMessage({ imageData: imageData });
🎯 Pro Tip!
워커는 DOM에 직접 접근할 수 없어. 그래서 이미지 데이터를 ImageData 객체로 변환해서 전달하는 거야!
이렇게 하면 워커가 안전하게 픽셀 데이터만 처리할 수 있지. 🔒
🚀 고급 기법: Shared Worker와 Service Worker
일반 웹 워커 말고도 더 강력한 친구들이 있어! 😎
상황에 따라 적절한 워커를 선택하면 성능을 더욱 끌어올릴 수 있어.
🔗 Shared Worker (공유 워커)
여러 탭이나 창에서 하나의 워커를 공유할 수 있어!
예를 들어, 채팅 앱을 여러 탭에서 열었을 때 하나의 웹소켓 연결만 유지하고 싶다면?
Shared Worker가 딱이야! 💬
// sharedWorker.js
let connections = [];
self.addEventListener('connect', function(e) {
const port = e.ports[0];
connections.push(port);
port.addEventListener('message', function(e) {
// 모든 연결된 탭에 메시지 브로드캐스트
connections.forEach(conn => {
conn.postMessage(e.data);
});
});
port.start();
});
// main.js
const sharedWorker = new SharedWorker('sharedWorker.js');
sharedWorker.port.start();
sharedWorker.port.addEventListener('message', function(e) {
console.log('다른 탭에서 온 메시지:', e.data);
});
sharedWorker.port.postMessage('안녕하세요!');
⚙️ Service Worker (서비스 워커)
이건 좀 특별해! 네트워크 요청을 가로채서 캐싱하거나 오프라인 기능을 구현할 수 있어.
PWA(Progressive Web App)의 핵심 기술이지! 📱
// serviceWorker.js
// 설치 단계
self.addEventListener('install', function(e) {
e.waitUntil(
caches.open('v1').then(function(cache) {
return cache.addAll([
'/',
'/styles.css',
'/script.js',
'/image.jpg'
]);
})
);
});
// 네트워크 요청 가로채기
self.addEventListener('fetch', function(e) {
e.respondWith(
caches.match(e.request).then(function(response) {
// 캐시에 있으면 캐시 반환, 없으면 네트워크 요청
return response || fetch(e.request);
})
);
});
// main.js
if ('serviceWorker' in navigator) {
navigator.serviceWorker.register('/serviceWorker.js')
.then(function(registration) {
console.log('서비스 워커 등록 성공! 🎉');
})
.catch(function(error) {
console.log('등록 실패:', error);
});
}
⚡ 실전 성능 최적화 전략
이제 실제 프로젝트에서 어떻게 활용하는지 알아보자! 🎯
재능넷 같은 플랫폼에서도 이런 기술들이 사용자 경험을 크게 개선할 수 있어.
| 상황 | 워커 사용 | 이유 |
|---|---|---|
| 대용량 데이터 정렬/필터링 | ✅ 추천 | 수천~수만 개 데이터 처리 시 UI 블로킹 방지 |
| 이미지/비디오 처리 | ✅ 추천 | 픽셀 단위 연산은 매우 무거움 |
| 암호화/해시 계산 | ✅ 추천 | CPU 집약적 작업 |
| 복잡한 수학 계산 | ✅ 추천 | 과학 계산, 시뮬레이션 등 |
| 간단한 DOM 조작 | ❌ 불필요 | 오버헤드가 더 클 수 있음 |
| 짧은 계산 (1ms 이하) | ❌ 불필요 | 워커 생성 비용이 더 큼 |
재능넷에서 수천 개의 재능을 검색한다고 생각해보자! 🔍
사용자가 검색어를 입력할 때마다 필터링하면 화면이 버벅일 수 있어.
이걸 워커로 해결해보자:
// searchWorker.js
self.addEventListener('message', function(e) {
const { talents, searchTerm, filters } = e.data;
// 복잡한 필터링 로직
const results = talents.filter(talent => {
// 검색어 매칭
const matchesSearch = talent.title.toLowerCase()
.includes(searchTerm.toLowerCase()) ||
talent.description.toLowerCase()
.includes(searchTerm.toLowerCase());
// 카테고리 필터
const matchesCategory = !filters.category ||
talent.category === filters.category;
// 가격 범위 필터
const matchesPrice = talent.price >= filters.minPrice &&
talent.price <= filters.maxPrice;
// 평점 필터
const matchesRating = talent.rating >= filters.minRating;
return matchesSearch && matchesCategory &&
matchesPrice && matchesRating;
});
// 정렬
results.sort((a, b) => {
if (filters.sortBy === 'price') {
return a.price - b.price;
} else if (filters.sortBy === 'rating') {
return b.rating - a.rating;
}
return 0;
});
self.postMessage({ results: results });
});
// main.js
const searchWorker = new Worker('searchWorker.js');
let searchTimeout;
// 검색 입력 이벤트
document.getElementById('searchInput').addEventListener('input', function(e) {
// 디바운싱: 입력이 멈춘 후 300ms 뒤에 검색
clearTimeout(searchTimeout);
searchTimeout = setTimeout(() => {
searchWorker.postMessage({
talents: allTalents, // 전체 재능 데이터
searchTerm: e.target.value,
filters: getCurrentFilters()
});
}, 300);
});
searchWorker.addEventListener('message', function(e) {
// UI 업데이트는 메인 스레드에서
displaySearchResults(e.data.results);
// 이 동안에도 사용자는 스크롤하거나 다른 작업 가능! 🎉
});
💡 디바운싱(Debouncing)과 함께 쓰면 금상첨화!
사용자가 타이핑할 때마다 워커를 호출하면 오히려 비효율적이야.
입력이 멈춘 후 일정 시간(보통 300ms) 뒤에 한 번만 호출하는 게 좋아! ⏱️
여러 개의 워커를 미리 만들어두고 작업을 분산시키는 고급 기법이야! 🏊♂️
대량의 작업을 병렬로 처리할 때 엄청 효과적이지.
class WorkerPool {
constructor(workerScript, poolSize = 4) {
this.workers = [];
this.taskQueue = [];
this.availableWorkers = [];
// 워커 풀 생성
for (let i = 0; i < poolSize; i++) {
const worker = new Worker(workerScript);
worker.id = i;
worker.addEventListener('message', (e) => {
this.handleWorkerComplete(worker, e.data);
});
this.workers.push(worker);
this.availableWorkers.push(worker);
}
}
// 작업 추가
addTask(data) {
return new Promise((resolve, reject) => {
const task = { data, resolve, reject };
if (this.availableWorkers.length > 0) {
this.executeTask(task);
} else {
this.taskQueue.push(task);
}
});
}
executeTask(task) {
const worker = this.availableWorkers.pop();
worker.currentTask = task;
worker.postMessage(task.data);
}
handleWorkerComplete(worker, result) {
worker.currentTask.resolve(result);
worker.currentTask = null;
// 대기 중인 작업이 있으면 실행
if (this.taskQueue.length > 0) {
const nextTask = this.taskQueue.shift();
this.executeTask(nextTask);
} else {
this.availableWorkers.push(worker);
}
}
// 모든 워커 종료
terminate() {
this.workers.forEach(worker => worker.terminate());
}
}
// 사용 예시
const pool = new WorkerPool('dataProcessor.js', 4);
// 100개의 이미지를 병렬 처리
const images = [...Array(100)].map((_, i) => `image${i}.jpg`);
Promise.all(
images.map(image => pool.addTask({ image }))
).then(results => {
console.log('모든 이미지 처리 완료! 🎉');
console.log('결과:', results);
});
🐛 주의사항과 디버깅 팁
웹 워커를 쓸 때 주의해야 할 점들을 알아보자! 🚨
이거 모르면 삽질할 수 있어...
⚠️ 워커에서 할 수 없는 것들
❌ DOM 접근 (document, window 객체 사용 불가)
❌ 부모 페이지의 함수 직접 호출
❌ localStorage, sessionStorage 접근 (일부 브라우저)
❌ alert(), confirm() 같은 동기 API
✅ 워커에서 할 수 있는 것들
✔️ XMLHttpRequest, Fetch API로 네트워크 요청
✔️ WebSocket 연결
✔️ IndexedDB 사용
✔️ 타이머 함수 (setTimeout, setInterval)
✔️ 다른 워커 생성 (서브 워커)
워커 안에서 뭐가 일어나는지 보려면? 크롬 개발자 도구를 활용하자! 🛠️
1. 콘솔 로그 확인
워커 안에서도 console.log()를 쓸 수 있어!
크롬 개발자 도구 → Sources → Threads에서 워커를 선택하면 로그를 볼 수 있지.
// worker.js
console.log('워커 시작!');
self.addEventListener('message', function(e) {
console.log('받은 데이터:', e.data);
// 작업 수행
const result = processData(e.data);
console.log('처리 결과:', result);
self.postMessage(result);
});
2. 에러 핸들링
워커에서 에러가 나면 메인 스레드에서 잡을 수 있어:
// main.js
const worker = new Worker('worker.js');
worker.addEventListener('error', function(e) {
console.error('워커 에러 발생!');
console.error('파일:', e.filename);
console.error('라인:', e.lineno);
console.error('메시지:', e.message);
// 사용자에게 친절한 메시지 표시
showErrorMessage('처리 중 오류가 발생했습니다. 다시 시도해주세요.');
});
// worker.js
self.addEventListener('error', function(e) {
console.error('워커 내부 에러:', e);
// 에러 정보를 메인 스레드로 전송
self.postMessage({
type: 'error',
message: e.message
});
});
3. 성능 측정
워커를 쓰면 정말 빨라지는지 확인해보자! ⏱️
// 워커 없이 실행
console.time('메인 스레드 처리');
const result1 = heavyCalculation(data);
console.timeEnd('메인 스레드 처리');
// 출력: 메인 스레드 처리: 2500ms
// 워커로 실행
console.time('워커 처리');
worker.postMessage(data);
worker.addEventListener('message', function(e) {
console.timeEnd('워커 처리');
// 출력: 워커 처리: 2480ms
// (하지만 이 동안 UI는 멈추지 않았어! 🎉)
});
워커와 메인 스레드 사이에 데이터를 주고받을 때는 복사가 일어나.
큰 데이터를 보내면 그만큼 시간이 걸려! 😰
이럴 땐 Transferable Objects를 써보자:
// 일반적인 방법 (데이터 복사)
const bigArray = new Uint8Array(10000000); // 10MB
worker.postMessage({ data: bigArray });
// 복사 시간: ~50ms
// Transferable 방법 (소유권 이전)
const bigArray = new Uint8Array(10000000);
worker.postMessage({ data: bigArray }, [bigArray.buffer]);
// 전송 시간: ~1ms (거의 즉시!)
// 주의: 전송 후에는 메인 스레드에서 bigArray를 쓸 수 없어!
console.log(bigArray.length); // 0 (소유권이 워커로 넘어감)
💡 Transferable Objects 사용 가능한 타입
✅ ArrayBuffer
✅ MessagePort
✅ ImageBitmap
✅ OffscreenCanvas
대용량 바이너리 데이터를 다룰 때 필수! 🚀
🎯 실전 프로젝트 예제 모음
이제 진짜 써먹을 수 있는 실전 예제들을 모아봤어! 💪
복사해서 바로 쓸 수 있게 완전한 코드로 준비했어.
// csvWorker.js
self.addEventListener('message', function(e) {
const csvText = e.data.csvText;
const lines = csvText.split('\n');
const headers = lines[0].split(',');
const data = [];
// 헤더를 제외한 나머지 줄 파싱
for (let i = 1; i < lines.length; i++) {
if (!lines[i].trim()) continue;
const values = lines[i].split(',');
const row = {};
headers.forEach((header, index) => {
row[header.trim()] = values[index]?.trim();
});
data.push(row);
// 진행률 보고 (1000줄마다)
if (i % 1000 === 0) {
self.postMessage({
type: 'progress',
current: i,
total: lines.length
});
}
}
// 완료
self.postMessage({
type: 'complete',
data: data
});
});
// main.js
const csvWorker = new Worker('csvWorker.js');
document.getElementById('fileInput').addEventListener('change', function(e) {
const file = e.target.files[0];
const reader = new FileReader();
reader.onload = function(event) {
const csvText = event.target.result;
// 워커에게 파싱 요청
csvWorker.postMessage({ csvText: csvText });
// 로딩 표시
showLoadingBar();
};
reader.readAsText(file);
});
csvWorker.addEventListener('message', function(e) {
if (e.data.type === 'progress') {
// 진행률 업데이트
const percent = (e.data.current / e.data.total * 100).toFixed(1);
updateLoadingBar(percent);
} else if (e.data.type === 'complete') {
// 파싱 완료
hideLoadingBar();
displayData(e.data.data);
console.log(`${e.data.data.length}개 행 파싱 완료! 🎉`);
}
});
// thumbnailWorker.js
self.addEventListener('message', function(e) {
const { imageData, maxWidth, maxHeight } = e.data;
// 비율 계산
const ratio = Math.min(
maxWidth / imageData.width,
maxHeight / imageData.height
);
const newWidth = Math.floor(imageData.width * ratio);
const newHeight = Math.floor(imageData.height * ratio);
// 리사이징 (간단한 nearest-neighbor 알고리즘)
const srcData = imageData.data;
const dstData = new Uint8ClampedArray(newWidth * newHeight * 4);
for (let y = 0; y < newHeight; y++) {
for (let x = 0; x < newWidth; x++) {
const srcX = Math.floor(x / ratio);
const srcY = Math.floor(y / ratio);
const srcIndex = (srcY * imageData.width + srcX) * 4;
const dstIndex = (y * newWidth + x) * 4;
dstData[dstIndex] = srcData[srcIndex]; // R
dstData[dstIndex + 1] = srcData[srcIndex + 1]; // G
dstData[dstIndex + 2] = srcData[srcIndex + 2]; // B
dstData[dstIndex + 3] = srcData[srcIndex + 3]; // A
}
}
self.postMessage({
imageData: {
data: dstData,
width: newWidth,
height: newHeight
}
}, [dstData.buffer]);
});
// main.js
const thumbnailWorker = new Worker('thumbnailWorker.js');
function createThumbnail(imageElement, maxWidth = 200, maxHeight = 200) {
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
canvas.width = imageElement.width;
canvas.height = imageElement.height;
ctx.drawImage(imageElement, 0, 0);
const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
thumbnailWorker.postMessage({
imageData: imageData,
maxWidth: maxWidth,
maxHeight: maxHeight
});
}
thumbnailWorker.addEventListener('message', function(e) {
const { imageData } = e.data;
// 썸네일 캔버스에 그리기
const thumbnailCanvas = document.getElementById('thumbnail');
thumbnailCanvas.width = imageData.width;
thumbnailCanvas.height = imageData.height;
const ctx = thumbnailCanvas.getContext('2d');
const newImageData = new ImageData(
imageData.data,
imageData.width,
imageData.height
);
ctx.putImageData(newImageData, 0, 0);
console.log('썸네일 생성 완료! 📸');
});
// hashWorker.js
// PBKDF2 해싱 (실제로는 crypto API 사용 권장)
async function hashPassword(password, salt, iterations = 100000) {
const encoder = new TextEncoder();
const data = encoder.encode(password + salt);
let hash = data;
for (let i = 0; i < iterations; i++) {
const buffer = await crypto.subtle.digest('SHA-256', hash);
hash = new Uint8Array(buffer);
// 진행률 보고
if (i % 10000 === 0) {
self.postMessage({
type: 'progress',
percent: (i / iterations * 100).toFixed(1)
});
}
}
// 16진수 문자열로 변환
return Array.from(hash)
.map(b => b.toString(16).padStart(2, '0'))
.join('');
}
self.addEventListener('message', async function(e) {
const { password, salt } = e.data;
try {
const hash = await hashPassword(password, salt);
self.postMessage({
type: 'complete',
hash: hash
});
} catch (error) {
self.postMessage({
type: 'error',
message: error.message
});
}
});
// main.js
const hashWorker = new Worker('hashWorker.js');
async function secureLogin(password) {
const salt = generateRandomSalt(); // 랜덤 솔트 생성
showLoadingMessage('비밀번호 처리 중...');
hashWorker.postMessage({
password: password,
salt: salt
});
}
hashWorker.addEventListener('message', function(e) {
if (e.data.type === 'progress') {
updateLoadingMessage(`처리 중... ${e.data.percent}%`);
} else if (e.data.type === 'complete') {
hideLoadingMessage();
// 해시된 비밀번호로 로그인 처리
sendLoginRequest(e.data.hash);
console.log('비밀번호 해싱 완료! 🔐');
} else if (e.data.type === 'error') {
hideLoadingMessage();
showError('비밀번호 처리 중 오류가 발생했습니다.');
}
});
🌐 브라우저 호환성과 폴리필
웹 워커는 대부분의 모던 브라우저에서 지원하지만, 항상 확인이 필요해! 🔍
✅ 브라우저 지원 현황
| 브라우저 | Web Worker | Shared Worker | Service Worker |
|---|---|---|---|
| Chrome | ✅ 4+ | ✅ 5+ | ✅ 40+ |
| Firefox | ✅ 3.5+ | ✅ 29+ | ✅ 44+ |
| Safari | ✅ 4+ | ✅ 16+ | ✅ 11.1+ |
| Edge | ✅ 12+ | ✅ 79+ | ✅ 17+ |
| IE | ✅ 10+ | ❌ | ❌ |
지원 여부 확인하기:
// Web Worker 지원 확인
if (typeof Worker !== 'undefined') {
console.log('Web Worker 지원! 🎉');
const worker = new Worker('worker.js');
} else {
console.log('Web Worker 미지원 😢');
// 폴백 로직 실행
fallbackFunction();
}
// Shared Worker 지원 확인
if (typeof SharedWorker !== 'undefined') {
console.log('Shared Worker 지원!');
} else {
console.log('Shared Worker 미지원');
}
// Service Worker 지원 확인
if ('serviceWorker' in navigator) {
console.log('Service Worker 지원!');
} else {
console.log('Service Worker 미지원');
}
워커를 지원하지 않는 브라우저를 위한 대비책! 🛡️
// 워커 래퍼 클래스
class SmartWorker {
constructor(workerScript, fallbackFunction) {
this.useWorker = typeof Worker !== 'undefined';
if (this.useWorker) {
this.worker = new Worker(workerScript);
this.worker.addEventListener('message', (e) => {
if (this.onMessage) {
this.onMessage(e.data);
}
});
} else {
this.fallbackFunction = fallbackFunction;
}
}
postMessage(data) {
if (this.useWorker) {
this.worker.postMessage(data);
} else {
// 워커 없이 메인 스레드에서 실행
setTimeout(() => {
const result = this.fallbackFunction(data);
if (this.onMessage) {
this.onMessage(result);
}
}, 0);
}
}
addEventListener(event, callback) {
if (event === 'message') {
this.onMessage = callback;
}
}
terminate() {
if (this.useWorker && this.worker) {
this.worker.terminate();
}
}
}
// 사용 예시
const smartWorker = new SmartWorker(
'heavyCalculation.js',
// 폴백 함수
function(data) {
// 워커 없이 실행할 로직
return performCalculation(data);
}
);
smartWorker.addEventListener('message', function(result) {
console.log('결과:', result);
});
smartWorker.postMessage({ value: 100 });
📚 실무에서의 베스트 프랙티스
실제 프로젝트에서 워커를 쓸 때 알아두면 좋은 팁들! 💎
이건 진짜 경험에서 나온 노하우야.
1️⃣ 워커 재사용하기
워커를 매번 새로 만들지 말고 재사용하자! 생성 비용이 꽤 크거든. 💰
// ❌ 나쁜 예
function processData(data) {
const worker = new Worker('processor.js'); // 매번 생성
worker.postMessage(data);
worker.addEventListener('message', (e) => {
console.log(e.data);
worker.terminate(); // 바로 종료
});
}
// ✅ 좋은 예
const processorWorker = new Worker('processor.js'); // 한 번만 생성
function processData(data) {
processorWorker.postMessage(data);
}
processorWorker.addEventListener('message', (e) => {
console.log(e.data);
});
// 페이지를 떠날 때만 종료
window.addEventListener('beforeunload', () => {
processorWorker.terminate();
});
2️⃣ 타임아웃 설정하기
워커가 너무 오래 걸리면? 타임아웃을 설정해서 사용자 경험을 지키자! ⏰
function processWithTimeout(worker, data, timeout = 5000) {
return new Promise((resolve, reject) => {
let timeoutId;
const messageHandler = (e) => {
clearTimeout(timeoutId);
worker.removeEventListener('message', messageHandler);
resolve(e.data);
};
worker.addEventListener('message', messageHandler);
worker.postMessage(data);
timeoutId = setTimeout(() => {
worker.removeEventListener('message', messageHandler);
reject(new Error('워커 타임아웃! 작업이 너무 오래 걸립니다.'));
}, timeout);
});
}
// 사용
try {
const result = await processWithTimeout(worker, bigData, 3000);
console.log('결과:', result);
} catch (error) {
console.error('타임아웃 발생:', error.message);
showUserMessage('처리 시간이 너무 오래 걸립니다. 데이터를 줄여주세요.');
}
3️⃣ 에러 복구 전략
워커가 죽었을 때 자동으로 재시작하는 로직! 🔄
class ResilientWorker {
constructor(workerScript, maxRetries = 3) {
this.workerScript = workerScript;
this.maxRetries = maxRetries;
this.retryCount = 0;
this.createWorker();
}
createWorker() {
this.worker = new Worker(this.workerScript);
this.worker.addEventListener('error', (e) => {
console.error('워커 에러:', e.message);
if (this.retryCount < this.maxRetries) {
this.retryCount++;
console.log(`워커 재시작 시도 (${this.retryCount}/${this.maxRetries})`);
setTimeout(() => {
this.createWorker();
}, 1000 * this.retryCount); // 점진적 백오프
} else {
console.error('워커 재시작 실패. 최대 재시도 횟수 초과.');
if (this.onFatalError) {
this.onFatalError();
}
}
});
this.worker.addEventListener('message', (e) => {
this.retryCount = 0; // 성공하면 카운트 리셋
if (this.onMessage) {
this.onMessage(e.data);
}
});
}
postMessage(data) {
this.worker.postMessage(data);
}
}
// 사용
const resilientWorker = new ResilientWorker('unstableWorker.js');
resilientWorker.onMessage = (data) => {
console.log('받은 데이터:', data);
};
resilientWorker.onFatalError = () => {
showUserMessage('서비스에 일시적인 문제가 있습니다. 잠시 후 다시 시도해주세요.');
};
4️⃣ 메모리 관리
워커도 메모리를 쓰니까 관리가 필요해! 🧹
// 워커 매니저 클래스
class WorkerManager {
constructor() {
this.workers = new Map();
this.maxWorkers = 4;
}
getWorker(name, script) {
if (!this.workers.has(name)) {
if (this.workers.size >= this.maxWorkers) {
// 가장 오래된 워커 제거
const oldestKey = this.workers.keys().next().value;
this.terminateWorker(oldestKey);
}
this.workers.set(name, {
worker: new Worker(script),
lastUsed: Date.now()
});
}
this.workers.get(name).lastUsed = Date.now();
return this.workers.get(name).worker;
}
terminateWorker(name) {
if (this.workers.has(name)) {
this.workers.get(name).worker.terminate();
this.workers.delete(name);
console.log(`워커 ${name} 종료됨`);
}
}
// 일정 시간 사용하지 않은 워커 정리
cleanupIdleWorkers(idleTime = 60000) { // 1분
const now = Date.now();
for (const [name, data] of this.workers.entries()) {
if (now - data.lastUsed > idleTime) {
this.terminateWorker(name);
}
}
}
terminateAll() {
for (const name of this.workers.keys()) {
this.terminateWorker(name);
}
}
}
// 전역 워커 매니저
const workerManager = new WorkerManager();
// 주기적으로 유휴 워커 정리
setInterval(() => {
workerManager.cleanupIdleWorkers();
}, 30000); // 30초마다
// 사용
const imageWorker = workerManager.getWorker('image', 'imageProcessor.js');
const dataWorker = workerManager.getWorker('data', 'dataProcessor.js');
🎓 재능넷에서 배우고 나누기
웹 워커와 멀티스레딩, 생각보다 어렵지 않지? 😊
이런 기술들을 실제 프로젝트에 적용하면 사용자 경험이 확 달라져!
재능넷에서는 이런 웹 개발 기술을 가르치거나 배울 수 있어.
프론트엔드 성능 최적화, 웹 워커 실전 활용법 등
다양한 재능을 거래할 수 있으니 한번 둘러보는 것도 좋을 거야! 🚀
💡 학습 로드맵 추천
1️⃣ 기본 JavaScript 비동기 처리 (Promise, async/await)
2️⃣ 웹 워커 기초 (메시지 통신, 데이터 전송)
3️⃣ 실전 예제 구현 (이미지 처리, 데이터 파싱)
4️⃣ 고급 패턴 (워커 풀, Shared Worker)
5️⃣ 성능 측정 및 최적화
6️⃣ 실제 프로젝트 적용
재능넷에서 멘토를 찾아 1:1로 배우면 훨씬 빠르게 성장할 수 있어! 📚
🎬 마무리하며
자, 오늘 웹 워커와 멀티스레딩에 대해 엄청 많은 걸 배웠어! 🎉
핵심만 다시 정리해볼까?
🎯 핵심 요약
1. 메인 스레드 블로킹이란?
→ 무거운 작업이 UI를 멈추게 하는 현상
→ 사용자 경험을 크게 해치는 주범! 😱
2. 웹 워커의 역할
→ 백그라운드에서 독립적으로 작업 실행
→ 메인 스레드는 UI에만 집중 가능
→ 메시지 기반 통신으로 안전하게 데이터 교환
3. 언제 사용할까?
→ CPU 집약적 계산 (수학, 암호화)
→ 대용량 데이터 처리 (파싱, 필터링)
→ 이미지/비디오 처리
→ 복잡한 알고리즘 실행
4. 주의사항
→ DOM 접근 불가
→ 워커 생성 비용 고려
→ 데이터 전송 오버헤드 최소화
→ 에러 처리 필수
5. 고급 기법
→ Shared Worker: 여러 탭 간 공유
→ Service Worker: 네트워크 캐싱, PWA
→ Worker Pool: 병렬 처리 최적화
→ Transferable Objects: 고속 데이터 전송
🚀 실전 적용 팁
✨ 시작은 작게
처음부터 복잡한 워커 풀을 만들 필요 없어.
간단한 계산 작업부터 워커로 옮겨보자!
📊 성능 측정은 필수
워커를 쓴다고 무조건 빨라지는 건 아니야.
console.time()으로 전후 비교해보고 적용하자!
🔍 사용자 피드백 제공
무거운 작업 중에는 로딩 바나 진행률을 보여줘.
사용자가 기다리는 게 덜 답답하거든! ⏳
🛡️ 에러 처리 철저히
워커가 죽으면 사용자는 아무것도 모르고 기다려.
타임아웃과 에러 핸들링으로 안전장치를 만들자!
🎨 점진적 개선
모든 걸 한 번에 워커로 옮기지 말고,
가장 무거운 작업부터 하나씩 최적화하자!
이제 너도 웹 워커 마스터! 🎓
오늘 배운 내용을 실제 프로젝트에 적용해보고,
사용자들이 "와, 이 사이트 진짜 빠르다!"라고 말하는 걸 경험해봐.
그 느낌, 정말 짜릿하거든! ⚡
궁금한 점이 있거나 더 배우고 싶다면
재능넷에서 웹 개발 전문가들을 만나보는 것도 좋은 방법이야.
실전 경험이 풍부한 개발자들이 1:1로 코칭해줄 수 있거든! 😊
자, 이제 코딩하러 가볼까? 화이팅! 💪✨
🎉 축하합니다!
웹 워커와 멀티스레딩의 세계를 정복했어요!
이제 당신의 웹 애플리케이션은 날아다닐 거예요! 🚀
Happy Coding! 💻✨
관련 키워드
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.