docs(10_Wiki): Topic_Business/General/Graphic/Programming을 Topics/ 하위로 이동

최상위 10_Wiki/Topic_*였던 4개 카테고리 폴더를 10_Wiki/Topics/Topic_* 로 재배치. 콘텐츠 변경 없음(순수 폴더 이동) — Topics/ 하위 나머지 폴더는 이미 지난 커밋에서 전부 정리된 상태(잔존 항목은 에이전트 운영 상태 및 사용자가 보존을 요청한 업데이트0615/무제 3.canvas 뿐).
2026-07-05 00:44:01 +09:00
parent e9cbf23ab5
commit 9a135bd19d
6127 changed files with 0 additions and 0 deletions
@@ -0,0 +1,189 @@
+---
+id: wiki-2026-0508-garbage-collection
+title: Garbage Collection
+category: 10_Wiki/Topics
+status: verified
+canonical_id: self
+aliases: [GC, Garbage Collector, Memory Management]
+duplicate_of: none
+source_trust_level: A
+confidence_score: 0.9
+verification_status: applied
+tags: [runtime, memory, performance, vm]
+raw_sources: []
+last_reinforced: 2026-05-10
+github_commit: pending
+tech_stack:
+  language: java
+  framework: jvm
+---
+
+# Garbage Collection
+
+## 매 한 줄
+> **"매 unreachable memory를 자동으로 reclaim한다"**. 매 GC는 manual malloc/free의 cognitive burden을 제거 — McCarthy의 Lisp(1959)에서 시작, modern V8/HotSpot/Go의 generational + concurrent collector로 evolution. 2026 trade-off는 매 throughput vs latency vs memory overhead.
+
+## 매 핵심
+
+### 매 Algorithm 분류
+- **Mark-and-sweep**: 매 reachable mark → unreachable sweep (fragmentation)
+- **Copying (semi-space)**: 매 live obj 새 space로 copy (50% memory waste)
+- **Mark-compact**: 매 mark 후 live obj 한쪽 끝으로 compact
+- **Reference counting**: 매 ref count 0 즉시 free (cycle 문제)
+
+### 매 Generational Hypothesis
+- **매 most objects die young**: 매 short-lived 95%+
+- **Young gen** (eden + survivor): 매 frequent, fast minor GC
+- **Old gen** (tenured): 매 infrequent, expensive major GC
+- **매 write barrier**: old → young reference tracking
+
+### 매 응용
+1. JVM (G1, ZGC, Shenandoah) — sub-ms pause.
+2. V8 (Orinoco) — concurrent + parallel + incremental.
+3. Go (tricolor concurrent) — sub-ms STW pause.
+4. .NET (Server GC, regions) — generational + LOH.
+
+## 💻 패턴
+
+### JVM ZGC 설정 (sub-ms pause)
+```bash
+java -XX:+UseZGC \
+     -XX:+ZGenerational \
+     -Xmx16g \
+     -XX:SoftMaxHeapSize=14g \
+     -jar app.jar
+```
+
+### Go GC tuning
+```go
+import "runtime/debug"
+
+func init() {
+    // 매 GOGC=100 default — 100% growth 시 trigger
+    debug.SetGCPercent(50) // 매 lower = more frequent, less memory
+    
+    // 매 hard memory limit (Go 1.19+)
+    debug.SetMemoryLimit(8 << 30) // 매 8GB
+}
+
+// 매 manual hint after large alloc
+runtime.GC()
+```
+
+### V8 Heap snapshot (Node.js)
+```javascript
+const v8 = require('v8');
+const fs = require('fs');
+
+// 매 heap snapshot for leak analysis
+const snapshot = v8.writeHeapSnapshot();
+console.log(`Heap snapshot: ${snapshot}`);
+
+// 매 heap statistics
+console.log(v8.getHeapStatistics());
+// { total_heap_size, used_heap_size, heap_size_limit, ... }
+```
+
+### Reference cycle break (Python)
+```python
+import weakref
+
+class Parent:
+    def __init__(self):
+        self.children = []
+
+class Child:
+    def __init__(self, parent):
+        # 매 strong cycle: parent ↔ child → leak
+        # self.parent = parent
+        # 매 fix: weakref
+        self.parent = weakref.ref(parent)
+    
+    def get_parent(self):
+        return self.parent()  # 매 None if collected
+```
+
+### Object pooling (avoid GC pressure)
+```csharp
+public class BulletPool
+{
+    private readonly Stack<Bullet> pool = new();
+    
+    public Bullet Rent()
+    {
+        if (pool.Count > 0) return pool.Pop();
+        return new Bullet();
+    }
+    
+    public void Return(Bullet b)
+    {
+        b.Reset();
+        pool.Push(b);
+    }
+}
+// 매 hot path에서 alloc 회피 → minor GC 감소
+```
+
+### Tricolor marking (concept, Go-style)
+```go
+// 매 white = unscanned, gray = in queue, black = scanned
+// invariant: 매 black은 white를 직접 reference 안 함
+// write barrier로 enforce:
+func writeBarrier(slot **Object, ptr *Object) {
+    if isBlack(slot) && isWhite(ptr) {
+        markGray(ptr)  // 매 promote to gray
+    }
+    *slot = ptr
+}
+```
+
+### .NET Span<T> (stack alloc, no GC)
+```csharp
+public int SumDigits(int n)
+{
+    Span<int> digits = stackalloc int[16];
+    int i = 0;
+    while (n > 0) { digits[i++] = n % 10; n /= 10; }
+    int sum = 0;
+    for (int j = 0; j < i; j++) sum += digits[j];
+    return sum; // 매 zero heap allocation
+}
+```
+
+## 매 결정 기준
+| 상황 | GC choice |
+|---|---|
+| Low-latency trading (JVM) | ZGC / Shenandoah (sub-ms pause) |
+| Throughput batch (JVM) | Parallel GC |
+| Game engine (managed) | Object pooling + GC.Collect at safe points |
+| Real-time embedded | Manual memory or Rust (no GC) |
+| Server-side Go | Default tricolor + GOGC tuning |
+
+**기본값**: 매 modern runtime의 default GC. 매 measure first (allocation profiler), tune later.
+
+## 🔗 Graph
+- 부모: [[Memory Management]]
+- 변형: [[Reference Counting]]
+- 응용: [[JVM]] · [[V8]]
+- Adjacent: [[ARC]]
+
+## 🤖 LLM 활용
+**언제**: 매 GC pause 분석, allocation hotspot 식별, runtime flag tuning 추천.
+**언제 X**: 매 Rust/C/C++ — GC 없음. 매 hard real-time — non-deterministic pause unacceptable.
+
+## ❌ 안티패턴
+- **Calling GC.Collect() 빈번**: 매 fragmentation + throughput 손실.
+- **Finalizer 의존**: 매 non-deterministic, GC overhead 증가 → IDisposable 사용.
+- **Large object heap thrash**: 매 LOH (.NET) 매번 alloc → fragmentation.
+- **String concat in loop**: 매 immutable string × N alloc → StringBuilder 사용.
+
+## 🧪 검증 / 중복
+- Verified (Jones, Hosking, Moss, "The Garbage Collection Handbook", 2nd ed., 2023).
+- Verified (Oracle ZGC docs, OpenJDK).
+- 신뢰도 A.
+
+## 🕓 Changelog
+| 날짜 | 변경 |
+|---|---|
+| 2026-05-08 | Phase 1 |
+| 2026-05-10 | Manual cleanup — generational GC + V8/Go/JVM modern collectors |