GC 동작 원리 — Serial부터 ZGC까지

public void createObjects() {
    // 객체 생성 — 힙에 할당
    List<String> names = new ArrayList<>();
    names.add("홍길동");
    // 메서드 끝나면 names는 더 이상 참조되지 않음
    // → GC가 알아서 수거
}

[Mark 단계]
GC Root에서 시작해서 참조 그래프를 따라가며 "살아있는 객체"에 표시

GC Root → A → B → C    (A, B, C는 살아있음)
           D            (D는 아무도 참조 안 함 → 가비지)

[Sweep 단계]
표시 안 된 객체(D)의 메모리를 해제

결과: [A][  ][B][  ][C][  ] ← 빈 공간이 듬성듬성 (단편화 발생)

[Mark]     살아있는 객체 표시
[Compact]  살아있는 객체를 한쪽으로 밀어서 빈 공간을 연속으로 만듦

결과: [A][B][C][          ] ← 빈 공간이 뒤쪽에 연속으로

[From 영역]  [A][ ][B][ ][C][ ]
                    ↓ 살아있는 것만 복사
[To 영역]    [A][B][C][          ]

복사 후 From 영역은 통째로 비움

┌─────────────────────────────────────────────────┐
│                     Heap                         │
│                                                  │
│  ┌──────────────────────┐  ┌──────────────────┐ │
│  │    Young Generation   │  │  Old Generation  │ │
│  │                       │  │                  │ │
│  │ ┌─────┐ ┌────┐┌────┐│  │                  │ │
│  │ │Eden │ │ S0 ││ S1 ││  │                  │ │
│  │ └─────┘ └────┘└────┘│  │                  │ │
│  └──────────────────────┘  └──────────────────┘ │
└─────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────┐
│              Metaspace (네이티브 메모리)           │
│  클래스 메타데이터, 메서드 정보 등                    │
└─────────────────────────────────────────────────┘

Minor GC: Young 영역만 수거
  └─ 빈번하게 발생, 빠름 (보통 수~수십 ms)

Major GC: Old 영역 수거
  └─ 덜 빈번하지만 오래 걸림

Full GC: Young + Old + Metaspace 전체 수거
  └─ 가장 오래 걸림, 피하고 싶은 녀석

// 1. new로 객체 생성 → Eden에 할당
Object obj = new Object();

// 2. Eden이 가득 차면 Minor GC 발생
//    살아남으면 Survivor(S0 또는 S1)로 이동

// 3. Minor GC를 반복하며 살아남을 때마다 age 증가
//    age가 임계값(기본 15)에 도달하면 Old로 승격(Promotion)

// 4. Old 영역이 가득 차면 Major GC 발생

# Serial GC 사용
java -XX:+UseSerialGC -jar app.jar

# Parallel GC 사용 (Java 8까지 기본)
java -XX:+UseParallelGC -XX:ParallelGCThreads=4 -jar app.jar

[CMS 4단계]
1. Initial Mark    (STW — 짧음) : GC Root에서 직접 참조하는 객체만 표시
2. Concurrent Mark (동시)       : 참조 그래프를 따라가며 표시
3. Remark          (STW — 짧음) : Concurrent Mark 중 변경된 참조 보정
4. Concurrent Sweep(동시)       : 가비지 수거

# Shenandoah 사용
java -XX:+UseShenandoahGC -jar app.jar

┌────┬────┬────┬────┬────┬────┬────┬────┐
│ E  │ E  │ S  │    │ O  │ O  │ H  │    │
├────┼────┼────┼────┼────┼────┼────┼────┤
│ O  │    │ E  │ O  │    │ O  │ O  │ E  │
├────┼────┼────┼────┼────┼────┼────┼────┤
│    │ O  │ O  │ E  │ S  │    │ O  │    │
└────┴────┴────┴────┴────┴────┴────┴────┘

E = Eden  S = Survivor  O = Old  H = Humongous  빈칸 = Free

1. Young GC (STW)
   Eden Region이 가득 차면 발생
   살아있는 객체를 Survivor Region으로 복사

2. Concurrent Marking
   Old Region 사용률이 IHOP(기본 45%) 넘으면 시작
   살아있는 객체 비율을 Region별로 계산

3. Mixed GC (STW)
   Young Region + 가비지가 많은 Old Region을 함께 수거
   "Garbage First" — 가비지가 가장 많은 Region부터 수거

4. Full GC (최후의 수단)
   Mixed GC로도 Old 영역 확보가 안 되면 발생
   싱글 스레드 Mark-Compact → 매우 느림 (Java 10부터 병렬화)

# G1 GC 사용 (Java 9+ 기본)
java -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \   # 목표 pause time (기본 200ms)
     -XX:InitiatingHeapOccupancyPercent=45 \  # IHOP
     -jar app.jar

64비트 포인터 구조:
┌──────────┬─────┬──────┬──────┬────────────────────────┐
│ 미사용    │ Fin │ Remap│ Mark │    객체 주소 (44비트)     │
│ (16비트)  │(1b) │ (1b) │(2b)  │    = 최대 16TB          │
└──────────┴─────┴──────┴──────┴────────────────────────┘

- Mark 비트   : 이 객체가 마킹되었는지
- Remap 비트  : 이 객체가 새 위치로 이동했는지
- Finalize 비트: finalizer 처리가 필요한지

// 애플리케이션 코드
Object ref = obj.field;

// JIT 컴파일 후 (ZGC의 Load Barrier 삽입)
Object ref = obj.field;
if (ref의 Colored Pointer 상태가 올바르지 않으면) {
    ref = slowPath(ref);  // 포인터 보정 (remap, mark 등)
}

1. Pause Mark Start     (STW — ~1ms) : GC Root 스캔
2. Concurrent Mark      (동시)        : 참조 그래프 순회하며 마킹
3. Pause Mark End       (STW — ~1ms) : 마킹 완료 확인
4. Concurrent Relocate  (동시)        : 살아있는 객체를 새 Region으로 이동
5. Concurrent Remap     (동시)        : 이전 주소를 새 주소로 갱신

# ZGC 사용 (Java 15+)
java -XX:+UseZGC -Xmx16g -jar app.jar

# Java 21+ Generational ZGC (세대별 ZGC)
java -XX:+UseZGC -XX:+ZGenerational -Xmx16g -jar app.jar

GC 스레드: "이 객체 참조 관계를 분석 중이야"
앱 스레드: "나 지금 그 객체 참조 바꿀 건데?"
         → 동시에 하면 정합성이 깨짐

// Safepoint가 되는 지점들
while (condition) {     // 루프 백엣지
    doSomething();
    // ← 여기가 Safepoint (JVM이 GC 플래그를 확인하는 지점)
}

obj.method();          // 메서드 호출/리턴 지점도 Safepoint

# Java 9+ 통합 로깅 (Unified Logging)
java -Xlog:gc*:file=gc.log:time,uptime,level,tags -jar app.jar

# Java 8 (레거시 방식)
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:gc.log -jar app.jar

[2026-03-19T10:15:30.123+0900][info][gc] GC(42) Pause Young (Normal)
    (G1 Evacuation Pause) 256M->128M(512M) 12.345ms
    │                                │        │     │         │
    │                                │        │     │         └─ STW 시간
    │                                │        │     └─ 전체 힙 크기
    │                                │        └─ GC 후 사용량
    │                                └─ GC 전 사용량
    └─ GC 번호

[info][gc] GC(42) Pause Young (Normal) (G1 Evacuation Pause)
    # Young GC, Eden → Survivor 복사

[info][gc] GC(100) Pause Young (Concurrent Start) (G1 Humongous Allocation)
    # Concurrent Marking 시작을 트리거하는 Young GC

[info][gc] GC(101) Concurrent Mark Cycle
    # Old Region의 살아있는 객체 분석

[info][gc] GC(102) Pause Young (Mixed) (G1 Evacuation Pause)
    # Mixed GC: Young + 일부 Old Region 수거

[warn][gc] GC(200) Pause Full (G1 Compaction Pause) 512M->256M(512M) 2345.678ms
    # Full GC 발생! — 2.3초 STW, 원인 분석 필요

# 기본 힙 설정
java -Xms4g    # 초기 힙 크기
     -Xmx4g    # 최대 힙 크기 (Xms와 같게 하면 리사이징 오버헤드 제거)
     -Xmn1g    # Young 영역 크기 (G1에서는 자동 관리하므로 보통 생략)
     -jar app.jar

                    처리량 중요?
                    ┌─ Yes → Parallel GC (배치, 데이터 파이프라인)
                    │
                    └─ No → 응답 시간이 중요
                            ┌─ 힙 < 4GB → G1 GC (대부분의 웹 서버)
                            │
                            └─ 힙 ≥ 4GB → ZGC (대규모 서비스, 실시간 시스템)

# G1 GC 튜닝 예시
java -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=100 \           # 목표 pause time 100ms
     -XX:InitiatingHeapOccupancyPercent=35 \  # IHOP 낮추면 Mixed GC 일찍 시작
     -Xms8g -Xmx8g \
     -jar app.jar