JVM의 구조(메모리 영역)를 설명해주세요.

┌─────────────────────────────────────────────────────────────────┐
│                            JVM                                  │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                   런타임 데이터 영역                        │  │
│  │  ┌─────────────┐  ┌─────────────────────────────────┐   │  │
│  │  │ Method Area │  │            Heap                  │   │  │
│  │  │ (공유)      │  │  ┌──────────────┐ ┌──────────┐  │   │  │
│  │  │ - 클래스 정보│  │  │Young Gen     │ │ Old Gen  │  │   │  │
│  │  │ - static 변수│  │  │ Eden|S0|S1  │ │          │  │   │  │
│  │  │ - 상수 풀   │  │  └──────────────┘ └──────────┘  │   │  │
│  │  └─────────────┘  └─────────────────────────────────┘   │  │
│  │                                                           │  │
│  │  ┌──────────────┐  ┌─────────┐  ┌──────────────────┐   │  │
│  │  │   JVM Stack  │  │   PC    │  │ Native Method     │   │  │
│  │  │  (스레드별)  │  │Register │  │    Stack          │   │  │
│  │  │ [Frame]      │  │(스레드별)│  │  (스레드별)       │   │  │
│  │  └──────────────┘  └─────────┘  └──────────────────┘   │  │
│  └──────────────────────────────────────────────────────────┘  │
│                                                                  │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐  │
│  │ Class Loader │  │ 실행 엔진    │  │ Native Method        │  │
│  │ Subsystem    │  │ (JIT 컴파일러│  │ Interface (JNI)      │  │
│  │              │  │  + 인터프리터)│  │                      │  │
│  └──────────────┘  └──────────────┘  └──────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

// 아래 코드 실행 시 Method Area에 저장되는 것들:

public class User {
  // static 변수 → Method Area에 저장
  private static int count = 0;
  private static final String TYPE = "USER";  // 상수 풀(Constant Pool)에 저장

  // 인스턴스 변수 → 메서드 영역에 필드 정보만, 실제 값은 Heap에
  private String name;
  private int age;

  // 메서드 바이트코드 → Method Area에 저장
  public String getName() { return name; }

  // 클래스 메타데이터:
  // - 클래스 이름, 접근 제한자
  // - 부모 클래스 참조
  // - 구현한 인터페이스 목록
  // - 필드/메서드 정보
}

// 런타임 상수 풀 (Runtime Constant Pool)
// - 리터럴 값 ("hello", 42 등)
// - 심볼릭 참조 (클래스/메서드/필드 이름)
String s1 = "hello"  // 상수 풀에서 참조
String s2 = "hello"  // 동일한 상수 풀 항목 참조
System.out.println(s1 == s2)  // true (같은 참조)

Heap
├── Young Generation (새로 생성된 객체들)
│   ├── Eden Space      : 새 객체가 최초 생성되는 공간
│   ├── Survivor 0 (S0) : Minor GC 생존 객체 임시 보관
│   └── Survivor 1 (S1) : Minor GC 생존 객체 임시 보관
│
└── Old Generation (오래된 객체들)
    └── Tenured Space   : Young Gen에서 오래 살아남은 객체

// 객체 생성 - Heap에 저장됨
User user = new User("김철수", 25)   // new → Eden Space에 객체 생성
int[] arr = new int[100]              // 배열도 Heap에 저장

// 참조 변수는 Stack에, 실제 객체 데이터는 Heap에
// Stack: [user → 참조값(주소)] ------→ Heap: { name:"김철수", age:25 }

// 객체가 참조를 잃으면 GC 대상
user = null  // Heap의 User 객체가 GC 대상이 됨

java.lang.OutOfMemoryError: Java heap space
→ Heap 공간 부족. -Xmx 증가 또는 메모리 누수 확인

java.lang.OutOfMemoryError: GC overhead limit exceeded
→ GC가 너무 자주 실행되어 작업 시간의 98%를 GC에 사용

java.lang.OutOfMemoryError: Metaspace
→ 클래스가 너무 많이 로드됨. -XX:MaxMetaspaceSize 증가

java.lang.OutOfMemoryError: Direct buffer memory
→ NIO Direct Buffer 부족. -XX:MaxDirectMemorySize 증가

스레드의 JVM Stack:
┌─────────────────────────────────────┐
│  Stack Frame 3: method3()           │ ← 현재 실행 중
│  ├── 지역 변수 배열 (Local Variables)│
│  │   [0] this, [1] param1, [2] x   │
│  ├── 피연산자 스택 (Operand Stack)  │
│  └── 현재 클래스의 런타임 상수 풀 참조│
├─────────────────────────────────────┤
│  Stack Frame 2: method2()           │
│  ├── 지역 변수: [0] this, [1] y    │
│  └── 피연산자 스택                  │
├─────────────────────────────────────┤
│  Stack Frame 1: method1()           │ ← 처음 호출된 메서드
│  └── ...                            │
└─────────────────────────────────────┘

public class StackExample {
  public static void main(String[] args) {
    // 스택 프레임 1: main()
    int x = 10;           // 지역 변수 → Stack에 저장
    String name = "철수"  // 참조값 → Stack에, 실제 문자열 → Heap에

    method1(x);           // method1 호출 → 새 스택 프레임 생성
  }  // main 반환 → 스택 프레임 1 제거

  static void method1(int n) {
    // 스택 프레임 2: method1()
    int result = n * 2;   // 지역 변수 → Stack
    method2(result);
  }  // 반환 → 스택 프레임 2 제거

  static void method2(int value) {
    // 스택 프레임 3: method2()
    System.out.println(value);
  }
}

// StackOverflowError 예시
static void infiniteRecursion() {
  infiniteRecursion()  // 종료 조건 없는 재귀 → StackOverflowError
}

// PC 레지스터 동작 (내부적으로)
// 바이트코드:
// 0: iload_1      ← PC = 0
// 1: iload_2      ← PC = 1
// 2: iadd         ← PC = 2
// 3: istore_3     ← PC = 3
// 4: return

// 멀티스레드 환경에서 컨텍스트 스위칭 시
// 각 스레드의 PC 레지스터가 다음 실행할 명령어 주소를 기억함
// Thread A: PC = 2 (iadd 실행 중)
// Thread B: PC = 15 (다른 명령어 실행 중)
// → 컨텍스트 스위치 후 각 스레드가 올바른 위치에서 재개 가능

// 네이티브 메서드 선언
public class NativeExample {
  // native 키워드 - JVM Stack 아닌 Native Method Stack 사용
  public native int nativeCalculation(int a, int b)

  static {
    System.loadLibrary("myNativeLib")  // .so / .dll 파일 로드
  }
}

// java.lang.Object의 메서드들도 native
public final native Class<?> getClass()
public native int hashCode()
protected native Object clone() throws CloneNotSupportedException

// 공유 영역 (스레드 안전 이슈 발생 가능)
// - Method Area: static 변수, 클래스 메타데이터
// - Heap: 객체 인스턴스

// 예: static 변수는 모든 스레드가 공유 → 동기화 필요
class Counter {
  private static int count = 0  // Heap에? NO, Method Area에

  // 동기화 없이는 스레드 안전하지 않음
  public static synchronized void increment() {
    count++
  }
}

// 스레드별 독립 영역 (스레드 안전)
// - JVM Stack: 지역 변수, 매개변수
// - PC Register: 현재 실행 주소
// - Native Method Stack: 네이티브 메서드 호출

// 지역 변수는 스레드별 Stack에 있으므로 동기화 불필요
void processData(int value) {
  int localVar = value * 2  // Stack에 저장 → 스레드 안전
}