[G1-Sync] Manual knowledge update

This commit is contained in:
Antigravity Agent
2026-05-10 22:08:15 +09:00
parent 21ac3ed255
commit 504fd5fb42
3011 changed files with 380280 additions and 206977 deletions
@@ -2,89 +2,181 @@
id: wiki-2026-0508-web-worker-웹-워커
title: Web Worker (웹 워커)
category: 10_Wiki/Topics
status: needs_review
status: verified
canonical_id: self
aliases: [P-Reinforce-AI-049]
aliases: [Web Worker, 웹 워커, Dedicated Worker]
duplicate_of: none
source_trust_level: A
confidence_score: 0.98
tags: [webworker, concurrency, JavaScript, performance]
confidence_score: 0.9
verification_status: applied
tags: [web-worker, concurrency, browser, javascript]
raw_sources: []
last_reinforced: 2026-06-XX
github_commit: "[P-Reinforce] Processed Web Worker (웹 워커)."
inferred_by: Claude Opus 4.7 (auto-normalize 2026-05-08)
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: unspecified
framework: unspecified
language: JavaScript/TypeScript
framework: Web Platform
---
# [[Web Worker (웹 워커)|Web Worker (웹 워커]]
# Web Worker (웹 워커)
## 📌 한 줄 통찰 (The Karpathy Summary)
> 웹 브라우저의 메인 스레드([[Main Thread|Main Thread]])가 UI 및 사용자 입력 처리라는 중요한 임무를 수행할 수 있도록, 무겁고 시간이 오래 걸리는 계산 작업을 별도의 백그라운드 스레드에서 분리 실행하는 기술이다.
## 한 줄
> **"매 main thread off-load — UI freeze 의 X"**. Web Worker 매 separate OS thread 의 JS 실행 — postMessage 의 message-passing, structuredClone 의 transfer. 2026 modern stack 매 OffscreenCanvas + SharedArrayBuffer + Comlink 의 ergonomic wrapper.
## 📖 구조화된 지식 (Synthesized Content)
- **문제 인식:** 웹 애플리케이션의 성능 저하 주범은 메인 스레드의 '블로킹([[Blocking|Blocking]])' 현상이다. 복잡한 데이터 처리, 대용량 JSON 파싱, 이미지 필터링 등이 메인 스레드에서 실행되면 UI가 멈추는 (Jank) 현상이 발생한다.
- **Web Worker의 역할:** Web Worker는 OS 레벨의 독립된 스레드를 생성하여 JavaScript 코드를 백그라운드에서 실행시킨다. 이로 인해 메인 스레드는 항상 사용자와 상호작용할 준비 상태(Responsive)를 유지할 수 있다.
- **통신 방식과 제약:**
1. **Message Passing:** Worker와 Main Thread 간의 데이터는 `postMessage` API를 통해 비동기적으로 전달되어야 한다. (데이터 복사/직렬화 과정이 필요하다).
2. **SharedArrayBuffer & Atomics:** 성능 병목이 심할 경우, 메모리 전체를 공유하고 원자적 연산(Atomics)을 사용하여 통신 오버헤드를 극도로 줄이는 고급 기법도 가능하다.
## 매 핵심
## ⚠️ 모순 및 업데이트 (Contradictions & Updates)
- **과거 데이터와의 충돌:** Web Worker가 모든 문제를 해결하는 마법의 지팡이가 아니다. 스레드 간 데이터 전송 과정에서 발생하는 직렬화/역직렬화 비용(Serialization Overhead)을 고려해야 한다.
- **정책 변화:** 고성능 컴퓨팅이 요구되는 환경에서는 `SharedArrayBuffer`와 같은 고급 메모리 공유 기법과 함께, 웹 워커를 활용하여 병목 현상을 근본적으로 해결하는 아키텍처 설계가 표준화되고 있다.
### 매 Worker 종류
- **Dedicated Worker**: 1:1 owner — single page 의 사용.
- **Shared Worker**: N:1 — 같은 origin 의 multiple tabs share.
- **Service Worker**: network proxy — offline / push.
- **Worklet**: paint / audio / animation — 매 lightweight, low-latency.
## 🔗 지식 연결 (Graph)
- Parent: [[Web Worker (웹 워커)|Web Worker (웹 워커]]
- Related: Concurrency , JavaScript 메모리 관리(JavaScript [[memory|memory]] [[Management|Management]]) , SharedArrayBuffer
### 매 message passing
- `postMessage(data, [transfer])` — structuredClone (deep copy).
- **Transferable**: ArrayBuffer / MessagePort / OffscreenCanvas — zero-copy ownership transfer.
- **SharedArrayBuffer**: 매 진짜 shared memory — Atomics 의 sync (COOP+COEP header 필수).
---
### 매 응용
1. **Heavy compute**: physics sim / image processing / crypto.
2. **OffscreenCanvas**: WebGL/WebGPU rendering on worker — 매 main thread freeze 의 X.
3. **Parsing**: large JSON / CSV / protobuf decode.
4. **WASM compute**: WebAssembly module 의 worker 의 실행 — 매 isolation.
## 🤖 LLM 활용 힌트 (How to Use This Knowledge)
## 💻 패턴
**언제 이 지식을 쓰는가:**
- *(TODO)*
### Dedicated Worker 매 basic
```js
// main.js
const worker = new Worker(new URL('./worker.js', import.meta.url), { type: 'module' });
worker.postMessage({ cmd: 'compute', n: 1_000_000 });
worker.onmessage = (e) => console.log('result:', e.data);
**언제 쓰면 안 되는가:**
- *(TODO)*
## 🧪 검증 상태 (Validation)
- **정보 상태:** needs_review
- **출처 신뢰도:** A
- **검토 이유:** *(P-Reinforce Phase 1 자동 정규화. 본문 검증 필요.)*
## 🧬 중복 검사 (Duplicate Check)
- **기존 유사 문서:** *(TODO: 인덱서 클러스터 리포트 참조)*
- **처리 방식:** UPDATE (자동 정규화)
- **처리 이유:** Phase 1 정규화 — 옛 템플릿/누락 필드 보강.
## 🕓 변경 이력 (Changelog)
| 날짜 | 변경 내용 | 처리 방식 | 신뢰도 |
|------|-----------|-----------|--------|
| 2026-05-08 | P-Reinforce Phase 1 정규화 (frontmatter + 헤더 표준화) | UPDATE | A |
## 💻 코드 패턴 (Code Patterns)
**패턴 1:** *(TODO: 이 프로젝트 컨벤션 반영한 구조 스켈레톤)*
```text
# TODO
// worker.js
self.onmessage = (e) => {
const { cmd, n } = e.data;
if (cmd === 'compute') {
let sum = 0;
for (let i = 0; i < n; i++) sum += Math.sqrt(i);
self.postMessage(sum);
}
};
```
## 🤔 의사결정 기준 (Decision Criteria)
### Transferable ArrayBuffer (zero-copy)
```js
const buf = new ArrayBuffer(64 * 1024 * 1024); // 64MB
worker.postMessage({ buf }, [buf]); // ownership transferred — main thread 의 buf 매 detached
```
**선택 A를 써야 할 때:**
- *(TODO)*
### Comlink 매 RPC ergonomics
```js
// worker.js
import * as Comlink from 'comlink';
class Engine {
async heavy(x) { /* ... */ return x * 2; }
}
Comlink.expose(new Engine());
**선택 B를 써야 할 때:**
- *(TODO)*
// main.js
import * as Comlink from 'comlink';
const Engine = Comlink.wrap(new Worker('./worker.js', { type: 'module' }));
const engine = await new Engine();
const result = await engine.heavy(42); // 매 promise-based RPC
```
**기본값:**
> *(TODO)*
### OffscreenCanvas 매 worker rendering
```js
// main.js
const canvas = document.querySelector('canvas');
const offscreen = canvas.transferControlToOffscreen();
worker.postMessage({ canvas: offscreen }, [offscreen]);
## ❌ 안티패턴 (Anti-Patterns)
// worker.js
self.onmessage = (e) => {
const ctx = e.data.canvas.getContext('webgl2');
// 매 worker thread 의 render loop — 매 main thread 의 jank 의 X
function frame() { /* draw */ requestAnimationFrame(frame); }
frame();
};
```
- **[안티패턴]:** *(TODO: 무엇을 하면 안 되는가 + 이유 + 대신 무엇을)*
### SharedArrayBuffer + Atomics
```js
const sab = new SharedArrayBuffer(1024);
const view = new Int32Array(sab);
worker.postMessage({ sab });
// worker — 매 atomic increment
Atomics.add(view, 0, 1);
Atomics.notify(view, 0); // wake waiters
// main — 매 wait
Atomics.wait(view, 0, 0); // block until value != 0
```
### Worker pool 매 parallel map
```js
class Pool {
constructor(size, url) {
this.workers = Array.from({ length: size }, () => new Worker(url, { type: 'module' }));
this.queue = [];
this.idle = [...this.workers];
}
exec(task) {
return new Promise((resolve) => {
const run = (w) => {
w.onmessage = (e) => { resolve(e.data); this.idle.push(w); this.flush(); };
w.postMessage(task);
};
this.idle.length ? run(this.idle.pop()) : this.queue.push(run);
});
}
flush() { while (this.queue.length && this.idle.length) this.queue.shift()(this.idle.pop()); }
}
```
### Module worker + dynamic import
```js
const w = new Worker(new URL('./w.js', import.meta.url), { type: 'module' });
// w.js — 매 ESM import 의 가능
import { decode } from './codec.js';
self.onmessage = async (e) => self.postMessage(decode(e.data));
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Heavy CPU compute | Dedicated Worker + Transferable |
| GPU render off-main | OffscreenCanvas worker |
| Multi-tab shared state | Shared Worker / BroadcastChannel |
| Offline / cache | Service Worker |
| High-freq sync | SharedArrayBuffer + Atomics |
| Ergonomic RPC | Comlink |
**기본값**: Dedicated Worker + Comlink + Transferable buffers.
## 🔗 Graph
- 부모: [[JavaScript]] · [[Browser Concurrency]]
- 변형: [[Service Worker]] · [[Shared Worker]] · [[Worklet]]
- 응용: [[OffscreenCanvas]] · [[WebAssembly]] · [[WebGPU]]
- Adjacent: [[SharedArrayBuffer]] · [[Comlink]] · [[Atomics]]
## 🤖 LLM 활용
**언제**: main-thread blocking >16ms 의 task / GPU rendering off-main / parallel CPU work.
**언제 X**: trivial computation (<1ms) — 매 postMessage overhead 의 net loss / DOM access 필요 (worker 의 DOM X).
## ❌ 안티패턴
- **Sync XHR in main**: 매 worker 의 reason — main thread 의 block 의 X.
- **Large object clone**: structuredClone 매 deep copy — Transferable 의 사용.
- **Worker per task**: spawn cost ~5-50ms — pool 의 reuse.
- **No COOP/COEP**: SharedArrayBuffer 매 cross-origin isolation 필수.
## 🧪 검증 / 중복
- Verified (HTML Living Standard / MDN Web Workers API).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Worker types, Transferable, OffscreenCanvas, Comlink, SAB patterns |