Java의 가비지 컬렉션(GC) 동작 원리와 주요 GC 알고리즘을 설명해주세요.

// GC는 "도달 가능성(Reachability)"으로 객체 생존 여부 판단
// GC Root에서 시작하여 참조를 따라갈 수 있으면 생존(Reachable)
// 참조를 따라갈 수 없으면 수거 대상(Unreachable)

// GC Root가 되는 것들:
// 1. JVM Stack의 지역 변수
// 2. Method Area의 static 변수
// 3. JNI에 의해 생성된 참조

void example() {
  // GC Root: 지역 변수
  User user1 = new User("김철수")  // user1 → User 객체 (Reachable)
  User user2 = new User("이영희")  // user2 → User 객체 (Reachable)

  user2 = user1  // 이영희 User 객체 → 참조 없음 → Unreachable → GC 대상

  user1 = null   // 김철수 User 객체 → 참조 없음 → GC 대상
  // 두 객체 모두 GC 대상이 됨
}

// 순환 참조도 GC가 수거 가능 (Reference Counting 방식은 불가능하지만
// Java의 Mark-and-Sweep 방식은 순환 참조도 처리 가능)
class Node {
  Node next
}
Node a = new Node()
Node b = new Node()
a.next = b  // a → b
b.next = a  // b → a (순환 참조)
a = null
b = null    // GC Root에서 도달 불가 → 순환 참조임에도 GC 대상

대부분의 객체는 금방 죽는다(Weak Generational Hypothesis)
→ 오래 살아남을수록 더 오래 생존할 가능성이 높다
→ 세대 구분으로 GC 효율 향상

1. 객체 생성 → Eden Space에 배치
   ┌──────────────────────────────┐
   │ Eden: [A][B][C][D][E][F][G] │  (거의 가득 참)
   │ S0:   []                     │
   │ S1:   []                     │
   └──────────────────────────────┘

2. Eden이 가득 차면 → Minor GC(Young GC) 실행
   - Mark: 살아있는 객체 표시 (A, C, E, G 살아있음)
   - Copy: 살아있는 객체를 S0으로 복사, age = 1
   ┌──────────────────────────────┐
   │ Eden: []                     │  (비워짐)
   │ S0:   [A(1)][C(1)][E(1)][G(1)] │
   │ S1:   []                     │
   └──────────────────────────────┘

3. 다시 Eden 가득 참 → Minor GC 재실행
   - Eden과 S0의 살아있는 객체를 S1으로 복사, age 증가
   ┌───────────────────────────────────┐
   │ Eden: []                           │
   │ S0:   []                           │
   │ S1:   [A(2)][E(2)][H(1)][I(1)]   │ (age 임계값 미만)
   └───────────────────────────────────┘

4. age가 임계값(기본 15) 도달 → Old Generation으로 승격(Promotion)
   - A가 age=15 도달 → Old Gen으로 이동

5. Old Gen이 가득 차면 → Major GC(Full GC) 실행
   - 더 오래, Stop-the-World 시간 더 길어짐

Minor GC (Young GC):
- Young Generation만 수거
- 자주 실행 (수 초~수십 초 간격)
- Stop-the-World: 짧음 (수 ms ~ 수십 ms)
- 대부분의 객체를 수거하므로 효율적

Major GC (Full GC):
- Old Generation + 전체 Heap 수거
- 드물게 실행
- Stop-the-World: 길 수 있음 (수십 ms ~ 수 초)
- 성능에 큰 영향 → 최소화가 GC 튜닝의 목표

Serial GC 동작:
Single Thread GC
┌──────────────────────┐
│ GC Thread: ████████  │ (GC 수행 중)
│ App Thread: ─ ─ ─ ─ │ (모두 정지)
└──────────────────────┘

Parallel GC 동작:
Multi-Thread GC
┌───────────────────────────┐
│ GC Thread1: ████          │
│ GC Thread2: ████          │ (병렬 GC)
│ GC Thread3: ████          │
│ App Thread: ─ ─ ─         │ (정지)
└───────────────────────────┘

CMS GC 동작:
┌──────────────────────────────────────────────┐
│ GC Thread:  ██ ──────── ██ ──────────        │
│              ↑           ↑                    │
│         Initial        Remark                 │
│           Mark         (STW)                  │
│           (STW)                               │
│ App Thread: ─ ████████ ─ ████████            │
└──────────────────────────────────────────────┘

G1 GC Heap 구조:
┌────────────────────────────────────────────────────┐
│ [E][E][E][O][O][ ][ ][ ][H][E][O][ ][E][E][E][O] │
│ [O][ ][E][E][O][O][ ][H][E][ ][O][E][ ][E][O][ ] │
│                                                     │
│ E = Eden Region                                     │
│ O = Old Region                                      │
│ H = Humongous Region (큰 객체)                     │
│ [ ] = Free Region                                   │
└────────────────────────────────────────────────────┘

동작 단계:
1. Young GC: Eden Region을 Survivor/Old로 이동 (병렬, STW)
2. Concurrent Marking: 전체 Heap을 앱 실행 중에 마킹
3. Mixed GC: Old Region 중 Garbage 많은 것부터 수거
4. Full GC: 공간 부족 시 전체 수거 (피해야 함)

ZGC 동작 (STW 최소화):
┌─────────────────────────────────────────────────────┐
│ GC Thread:  ─ ██████████████████████████ ─ ████    │
│               ↑                           ↑         │
│           Concurrent                   STW(짧음)    │
│           Mark/Relocate                             │
│ App Thread: █████ ─────────────────────── ─ █████  │
└─────────────────────────────────────────────────────┘

GC 성능의 3가지 목표 (동시에 모두 달성 불가):
1. Throughput (처리량): GC 시간을 제외한 애플리케이션 실행 시간 비율
2. Latency (지연): GC로 인한 일시 정지 시간
3. Footprint (공간): GC가 사용하는 메모리 양

GC 선택 기준:
┌─────────────────────────────────────────────────┐
│ 처리량 우선          → Parallel GC               │
│ 짧은 지연 우선       → G1 GC (권장)              │
│ 초저지연 (< 10ms)   → ZGC, Shenandoah           │
│ 소규모/단일코어      → Serial GC                  │
└─────────────────────────────────────────────────┘

// 흔한 메모리 누수 패턴들

// 1. static 컬렉션에 계속 추가
class CacheManager {
  private static Map<String, Object> cache = new HashMap<>()

  // 제거 없이 계속 추가 → 메모리 누수
  public static void add(String key, Object value) {
    cache.put(key, value)  // ❌ 크기 제한 없음
  }

  // 해결: WeakHashMap 또는 크기 제한
  private static Map<String, Object> cache = new LinkedHashMap<>() {
    protected boolean removeEldestEntry(Map.Entry eldest) {
      return size() > 1000  // 1000개 초과 시 가장 오래된 항목 제거
    }
  }
}

// 2. 리스너/콜백 해제 안 함
class EventBus {
  private List<EventListener> listeners = new ArrayList<>()

  void register(EventListener listener) {
    listeners.add(listener)  // 등록은 하지만
  }

  // unregister가 없으면 listeners가 계속 쌓임
  void unregister(EventListener listener) {
    listeners.remove(listener)  // 반드시 해제 필요
  }
}

// 3. try-with-resources로 자원 해제
try (Connection conn = dataSource.getConnection()
     PreparedStatement ps = conn.prepareStatement(sql)) {
  // 자동으로 close() 호출 → 메모리/연결 해제
}