📑 JAVA 01 - JAVA 객체 생성 과정과 JVM 메모리 구조 심화

1주차 1일차 - 객체 생성 과정과 JVM 메모리 구조 심화

Java 백엔드 면접에서 굉장히 자주 등장하는 질문:

“new 키워드로 객체 생성 시 어떤 일이 발생하나요?”

많은 경우:

• Heap에 객체 생성
• Stack에 참조 저장

정도로 끝난다.

하지만 실제 중견 이상 면접에서는:

• 클래스 로딩
• 메모리 할당
• 객체 초기화
• 참조 연결
• GC Root
• 객체 생명주기

까지 연결해서 설명할 수 있어야 한다.

특히 Spring 기반 백엔드에서는:

객체 생성 자체가 성능과 직결

되기 때문에 매우 중요하다.

---

JVM 메모리 구조

graph TD

JVM[JVM Memory]

JVM --> MA[Method Area]
JVM --> HEAP[Heap]
JVM --> STACK[Stack]

MA --> MA1[클래스 정보]
MA --> MA2[static 변수]
MA --> MA3[런타임 상수 풀]

HEAP --> H1[User 객체]
HEAP --> H2[Order 객체]
HEAP --> H3[String 객체]

STACK --> S1[Thread-1 Stack]
STACK --> S2[Thread-2 Stack]

JVM 메모리는 크게 다음 영역으로 나뉜다.

• Method Area
• Heap
• Stack
• PC Register
• Native Method Stack

오늘 핵심은:

• Heap
• Stack
• Method Area

이해다.

---

Heap

Heap은:

객체가 저장되는 메모리 영역

이다.

예시:

User user = new User();

실제 User 객체는 Heap에 생성된다.

---

왜 Heap은 공유 영역일까?

graph LR

T1[Thread-1] --> H[Heap의 User 객체]
T2[Thread-2] --> H

매우 중요한 질문.

Heap은:

여러 스레드가 동일 객체를 공유할 수 있도록 설계

되었다.

만약 스레드별 Heap을 사용한다면:

• 객체 공유 어려움
• 메모리 낭비 증가
• 객체 전달 비용 증가

문제가 발생한다.

즉:

“객체 공유 효율”

을 위해 Heap은 공유 메모리로 설계되었다.

---

Stack

Stack은:

메서드 호출과 지역 변수 저장 영역

이다.

예시:

public void test() {
    User user = new User();
}

여기서:

• user 변수 → Stack
• 실제 User 객체 → Heap

저장.

---

왜 Stack은 스레드별 독립일까?

graph TD

T1[Thread-1 Stack]
T2[Thread-2 Stack]

T1 --> A1[methodA]
T1 --> A2[local variable]

T2 --> B1[methodB]
T2 --> B2[local variable]

이유:

메서드 실행 흐름 충돌 방지

때문이다.

메서드 호출 상태는: 스레드마다 독립적이어야 한다.

따라서:

• 지역 변수
• 매개변수
• 반환 정보

등을 독립 관리한다.

---

Method Area

클래스 메타데이터 저장 영역.

저장 대상:

• 클래스 정보
• static 변수
• 런타임 상수 풀
• 메서드 정보

---

static 변수는 왜 별도 관리할까?

예시:

static int count = 0;

static은:

객체별 데이터가 아니라 클래스 공용 데이터

이다.

따라서: Heap 객체 내부가 아니라 별도 메모리 영역에서 관리한다.

---

객체 생성 과정

graph TD
A[new User 실행] --> B[ClassLoader 확인]
B --> C[Heap 메모리 할당]
C --> D[기본값 초기화]
D --> E[생성자 호출]
E --> F[Stack 참조 저장]
F --> G[GC Root 연결]

다음 코드 기준으로 보자.

User user = new User();

JVM 내부에서는 꽤 많은 과정이 발생한다.

---

1. 클래스 로딩 확인

JVM은 먼저:

User 클래스가 메모리에 존재하는가?

확인한다.

없으면:

• ClassLoader 동작
• .class 로딩

수행.

---

왜 런타임 로딩 구조일까?

Java는:

Runtime Dynamic Loading

지원 언어다.

즉: 필요한 시점에 클래스 로딩 가능.

장점:

• 메모리 효율
• 유연성
• 프레임워크 구현 용이

---

2. Heap 메모리 할당

객체 저장 공간 생성.

이때:

• 필드 기본값 초기화
• 메모리 확보

수행.

예시:

int -> 0
boolean -> false
reference -> null

---

왜 기본값 초기화를 할까?

Java 핵심 철학:

“안전성”

때문이다.

C/C++처럼: 쓰레기값 노출 방지 목적.

---

3. 생성자 호출

이후 생성자 실행.

new User();

생성자 내부 로직 수행.

---

4. 참조 연결

graph LR
S[Stack의 user 변수] --> H[Heap의 User 객체]

최종적으로:

User user

참조 변수가 Stack에 생성되고: Heap 객체 주소 참조.

구조:

Stack
user -----> Heap(User 객체)

---

GC Root와 객체 생명주기

Reachable 객체

graph TD
ROOT[GC Root]

ROOT --> USER[User 객체]
USER --> ORDER[Order 객체]

Unreachable 객체

graph TD
ROOT[GC Root]
OBJ[User 객체]

Java GC 핵심 기준:

Reachability(도달 가능성)

이다.

---

GC Root란?

대표 GC Root:

• Stack 지역 변수
• static 변수
• JNI 참조

---

왜 Reachability 기준을 사용할까?

단순 시간 기준 제거는 위험하다.

예시:

User user = cache.get();

오래된 객체라도: 여전히 사용 중일 수 있다.

따라서 JVM은:

“참조 가능 여부”

로 판단한다.

---

객체가 GC 대상이 되는 과정

예시:

public void test() {
    User user = new User();
}

메서드 종료 시:

• Stack Frame 제거
• user 참조 제거

발생.

이후 Heap 객체는:

GC Root로부터 도달 불가능

상태가 된다.

그때 GC 대상 가능.

---

왜 객체 생성 비용이 중요할까?

graph TD

A[객체 생성 증가] --> B[Heap 사용량 증가]
B --> C[GC 빈도 증가]
C --> D[Stop-The-World 증가]
D --> E[응답 지연 발생 가능]

Java는 객체 생성이 쉬운 언어다.

하지만 대규모 트래픽 환경에서는:

• 객체 생성 증가
• Heap 사용 증가
• GC 증가
• STW 증가

로 이어질 수 있다.

---

실제 장애 사례

대표 사례:

• API 응답마다 DTO 과다 생성
• 문자열 반복 생성
• 불필요한 객체 변환

결과:

• GC 과부하
• 응답 지연
• CPU 증가

발생 가능.

---

실무형 관점

Spring 서버는: 요청마다 매우 많은 객체를 생성한다.

예시:

• Request DTO
• Response DTO
• Entity
• 로그 객체

따라서:

객체 생성량 = 성능 영향 요소

가 된다.

---

Trade-off 관점

객체 생성 장점

• 코드 단순화
• 불변 객체 활용 가능
• 안정성 증가

---

단점

• GC 증가
• 메모리 사용 증가
• CPU 비용 증가

즉:

“안정성 vs 성능”

Trade-off 존재.

---

면접 꼬리 질문

자주 나오는 질문:

• 객체는 어디에 저장되는가?
• Stack과 Heap 차이는?
• 왜 Heap은 공유 메모리인가?
• static 변수는 어디에 저장되는가?
• GC Root란?
• 왜 Reachability 방식 사용하는가?
• 객체 생성 비용이 왜 중요한가?

---

좋은 답변 예시

graph TD

A[new User 호출] --> B[ClassLoader 확인]
B --> C[Heap 객체 생성]
C --> D[생성자 호출]
D --> E[Stack 참조 저장]
E --> F[GC Root 연결]
F --> G[참조 제거 시 GC 대상]

Java에서 객체 생성 시 먼저 클래스 로딩 여부를 확인합니다. 이후 Heap 영역에 객체 메모리를 할당하고, 생성자를 호출합니다. 참조 변수는 Stack에 저장되며, 객체는 GC Root로부터 도달 불가능해지면 GC 대상이 됩니다.

정도까지 설명 가능하면 상당히 좋은 답변이다.

---

현업에서 특히 중요한 포인트

실무에서는:

• 객체 생성량
• GC 빈도
• 메모리 사용량

이 성능과 직접 연결된다.

특히: 대량 트래픽 환경에서는:

“불필요한 객체 생성 줄이기”

가 성능 최적화 핵심 중 하나다.

---

핵심 요약

핵심은 다음이다.

• 객체는 Heap에 저장된다
• 참조 변수는 Stack에 저장된다
• static은 Method Area에 저장된다
• GC는 Reachability 기반으로 동작한다
• 객체 생성량은 성능과 직결된다

특히 중요한 건:

“객체 생성 → 메모리 → GC → 성능”

흐름을 연결해서 이해하는 것이다.