콘텐츠 대표 이미지 - ⚡ 웹 워커와 멀티스레딩으로 메인 스레드 블로킹 완벽 해결하기

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

브라우저를 멈추지 않는 똑똑한 개발 전략 🚀

안녕! 혹시 웹사이트 쓰다가 갑자기 화면이 얼어붙은 경험 있어? 🥶
버튼을 눌러도 반응이 없고, 스크롤도 안 되고... 이게 바로 메인 스레드 블로킹 현상이야.

오늘은 이 짜증나는 문제를 웹 워커(Web Worker)와 멀티스레딩 기법으로 깔끔하게 해결하는 방법을 알려줄게! 😎
프로그래밍 초보자도 이해할 수 있게 친구한테 설명하듯이 쉽게 풀어볼게~

🎯 메인 스레드가 뭔데? 왜 블로킹되는 거야?

먼저 기본부터 알아보자! 브라우저는 기본적으로 싱글 스레드로 동작해.
쉽게 말하면, 한 명의 일꾼이 모든 일을 처리하는 거지. 🏃‍♂️

이 일꾼(메인 스레드)이 하는 일들을 보면:

✅ JavaScript 코드 실행
✅ HTML/CSS 렌더링
✅ 사용자 이벤트 처리 (클릭, 스크롤 등)
✅ DOM 조작
✅ 애니메이션 처리

문제는 이 일꾼이 무거운 작업을 만나면 다른 일을 전혀 못한다는 거야! 😱
예를 들어, 엄청 큰 데이터를 계산하거나 복잡한 이미지 처리를 하는 동안에는
사용자가 버튼을 눌러도, 스크롤을 해도 아무 반응이 없어.

이게 바로 메인 스레드 블로킹이야!

싱글 스레드 (블로킹) 무거운 작업 실행 중... UI 업데이트 대기 사용자 입력 대기 애니메이션 대기 멀티 스레드 (논블로킹) 메인 스레드 워커 스레드 UI 업데이트 무거운 계산 사용자 입력 데이터 처리 애니메이션 이미지 처리 ❌ 모든 작업 멈춤 ✅ 동시 작업 가능

🎪 웹 워커(Web Worker)가 뭐야?

웹 워커는 쉽게 말해서 추가 일꾼을 고용하는 것이야! 🧑‍💼
메인 스레드가 혼자 일하느라 힘들면, 웹 워커라는 보조 일꾼을 불러서
무거운 작업을 맡기는 거지.

이렇게 하면 메인 스레드는 UI 관련 일에만 집중할 수 있어서
사용자는 항상 부드러운 경험을 할 수 있어! ✨

💡 웹 워커의 핵심 특징 🔹 백그라운드에서 독립적으로 실행
🔹 메인 스레드를 블로킹하지 않음
🔹 CPU 집약적인 작업에 최적화
🔹 메시지 기반으로 메인 스레드와 통신
🔹 DOM에 직접 접근 불가 (안전성 확보)

🛠️ 웹 워커 기본 사용법 - 실전 코드!

자, 이제 실제로 어떻게 쓰는지 코드로 알아보자! 😊
생각보다 엄청 간단해. 크게 3단계만 기억하면 돼:

1️⃣ 워커 파일 만들기 (worker.js)

먼저 워커가 실행할 작업을 별도 파일로 만들어야 해:

// 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);
});
2️⃣ 메인 스레드에서 워커 생성하기
// 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();
3️⃣ 실전 예제: 이미지 필터 처리

실제로 많이 쓰이는 예제를 하나 더 볼까? 📸
이미지에 필터를 적용하는 건 엄청 무거운 작업이야.
픽셀 하나하나를 다 계산해야 하거든!

// 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);
        });
}
Web Worker 일반 워커 단일 탭 CPU 집약 작업 데이터 처리 계산 작업 Shared Worker 공유 워커 탭 1 공유 탭 2 웹소켓 공유 상태 동기화 데이터 캐싱 Service Worker 서비스 워커 네트워크 프록시 캐시 관리 오프라인 지원 푸시 알림 백그라운드 동기화

⚡ 실전 성능 최적화 전략

이제 실제 프로젝트에서 어떻게 활용하는지 알아보자! 🎯
재능넷 같은 플랫폼에서도 이런 기술들이 사용자 경험을 크게 개선할 수 있어.

📊 언제 웹 워커를 써야 할까?
상황 워커 사용 이유
대용량 데이터 정렬/필터링 ✅ 추천 수천~수만 개 데이터 처리 시 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) 뒤에 한 번만 호출하는 게 좋아! ⏱️

🔄 워커 풀(Worker Pool) 패턴

여러 개의 워커를 미리 만들어두고 작업을 분산시키는 고급 기법이야! 🏊‍♂️
대량의 작업을 병렬로 처리할 때 엄청 효과적이지.

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

대용량 바이너리 데이터를 다룰 때 필수! 🚀

🎯 실전 프로젝트 예제 모음

이제 진짜 써먹을 수 있는 실전 예제들을 모아봤어! 💪
복사해서 바로 쓸 수 있게 완전한 코드로 준비했어.

📈 예제 1: CSV 파일 파싱 (대용량 데이터)
// 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}개 행 파싱 완료! 🎉`);
    }
});
🖼️ 예제 2: 이미지 썸네일 생성
// 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('썸네일 생성 완료! 📸');
});
🔐 예제 3: 비밀번호 해싱 (보안)
// 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 미지원');
}
🔄 폴백(Fallback) 전략

워커를 지원하지 않는 브라우저를 위한 대비책! 🛡️

// 워커 래퍼 클래스
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');
웹 워커 성능 최적화 체크리스트 해야 할 것들 ✅ 워커 재사용하기 타임아웃 설정 에러 핸들링 진행률 표시 Transferable 사용 메모리 관리 브라우저 호환성 체크 폴백 전략 준비 성능 측정 하지 말아야 할 것들 ❌ 매번 워커 생성 DOM 직접 접근 동기 API 사용 짧은 작업에 사용 에러 무시 무한 루프 과도한 메시지 전송 메모리 누수 방치 테스트 생략 성능 향상 효과 UI 반응성 +300% 처리 속도 +150% 사용자 만족도 +250% 이탈률 감소 -60%

🎓 재능넷에서 배우고 나누기

웹 워커와 멀티스레딩, 생각보다 어렵지 않지? 😊
이런 기술들을 실제 프로젝트에 적용하면 사용자 경험이 확 달라져!

재능넷에서는 이런 웹 개발 기술을 가르치거나 배울 수 있어.
프론트엔드 성능 최적화, 웹 워커 실전 활용법 등
다양한 재능을 거래할 수 있으니 한번 둘러보는 것도 좋을 거야! 🚀

💡 학습 로드맵 추천 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
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.