...

์๋ฐ์ ๋ฉ๋ชจ๋ฆฌ ์์ญ
์ด๋ฒ ํฌ์คํ ์์ ์๋ฐ(JAVA)๋ฅผ ์ฌ์ฉํ๋ ์ ์ฅ์์ ์์์ผ ํ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ ๋ฐ ํน์ง์ ๋ํด์ ์์๋ณด๋ ค๊ณ ํ๋ค.
์๋ฐ ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ฉด JVM(์๋ฐ ๊ฐ์ ๋จธ์ )์ OS๋ก๋ถํฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋น๋ฐ๊ณ , ๊ทธ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฉ๋์ ๋ฐ๋ผ์ ์ฌ๋ฌ ์์ญ์ผ๋ก ๋๋์ด ๊ด๋ฆฌ๋ฅผ ํ๋ค.
JVM์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ(Runtime Data Area)์ ํฌ๊ฒ Method(Static) ์์ญ, Stack ์์ญ, Heap ์์ญ์ผ๋ก ๊ตฌ๋ถ๋๊ณ ๋ฐ์ดํฐ ํ์ (์๋ฃํ)์ ๋ฐ๋ผ ๊ฐ ์์ญ์ ๋๋ ์ ํ ๋น ๋๊ฒ ๋๋ค.

์ปดํจํฐ์ ๋ฉ๋ชจ๋ฆฌ๋ ์ฌ์ฉํ ์ ์๋ ๊ณต๊ฐ์ด ํ์ ๋์ด ์๊ธฐ ๋๋ฌธ์ ์ด๋ป๊ฒ ๊ด๋ฆฌํ๋๋์ ๋ฐ๋ผ์ ํ๋ก๊ทธ๋จ์ ์ฑ๋ฅ(์๋ ๋ฑ)์ด ์ข์ฐ๋๋ค.
๊ทธ๋์ ๋ฉ๋ชจ๋ฆฌ ์ค๊ณ๊ฐ ์๋์ด ์๋ ํ๋ก๊ทธ๋จ์ ๋นํด ๊ทธ๋ ์ง ์์ ํ๋ก๊ทธ๋จ์ ์๋ ์ ํ ํ์์ด๋ ํ๊น ๋ฑ์ ํ์์ด ์ผ์ด๋ ํ๋ฅ ์ด ํฌ๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก ๊ฐ์ ๊ธฐ๋ฅ์ ํ๋ก๊ทธ๋จ์ด๋ผ ํ์ฌ๋ ๋ฉ๋ชจ๋ฆฌ์ ๊ด๋ฆฌ์ ๋ฐ๋ผ ์ฑ๋ฅ์ด ์ฐจ์ด๊ฐ ๋๊ฒ ๋๋ ๊ฒ์ด๋ค.
๋ฐ๋ผ์ Java ์ดํ๋ฆฌ์ผ์ด์ ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ๊ธฐ ์ํด์๋ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ์ ํน์ง์ ๋ํด ์ดํดํ ํ์๊ฐ ์๋ค.
์๋ฐ ๋ณ์์ ์ข ๋ฅ
๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์๊ธฐ ์ ์ ์๋ฐ์์ ์ ์ธ ์์น์ ๋ฐ๋ฅธ ๋ณ์์ ์ข ๋ฅ๋ฅผ ๋จผ์ ์์๋ณด๋๋ก ํ์.
๋ณ์๋ ํฌ๊ฒ ๋ค ์ข ๋ฅ๋ก ๋ณ์์ ์ ์ธ๋ ์์น์ ๋ฐ๋ผ์ ํด๋์ค๋ณ์, ์ธ์คํด์ค๋ณ์, ์ง์ญ๋ณ์, ๋งค๊ฐ๋ณ์๋ก ๋๋๋ค.

๋ณ์๋ช | ์ ์ธ์์น | ์ค๋ช |
ํด๋์ค ๋ณ์ (class variable) (= static ๋ณ์) |
ํด๋์ค ์์ญ | ํด๋์ค ์์ญ์์ ํ์
์์ static์ด ๋ถ๋ ๋ณ์ ๊ฐ์ฒด๋ฅผ ๊ณต์ ํ๋ ๋ณ์๋ก ์ฌ๋ฌ ๊ฐ์ฒด์์ ๊ณตํต์ผ๋ก ์ฌ์ฉํ๊ณ ์ถ์ ๋ ์ ์ |
์ธ์คํด์ค ๋ณ์ (instance variable) |
ํด๋์ค ์์ญ์์ static์ด ์๋ ๋ณ์ ๊ฐ๋ณ์ ์ธ ์ ์ฅ ๊ณต๊ฐ์ผ๋ก ๊ฐ์ฒด/์ธ์คํด์ค๋ง๋ค ๋ค๋ฅธ ๊ฐ ์ ์ฅ ๊ฐ๋ฅ โป ๊ฐ์ฒด/์ธ์คํด์ค ์์ฑ๋ง ํ๊ณ ์ฐธ์กฐ ๋ณ์๊ฐ ์๋ ๊ฒฝ์ฐ ๊ฐ๋น์ง ์ปฌ๋ ํฐ์ ์ํด ์๋ ์ ๊ฑฐ๋จ |
|
์ง์ญ ๋ณ์ (local variable) |
๋ฉ์๋ ์์ญ | ๋ฉ์๋ ๋ด์์ ์ ์ธ๋๊ณ ๋ฉ์๋ ์ํ์ด ๋๋๋ฉด ์๋ฉธ๋๋ ๋ณ์ ์ด๊น๊ฐ์ ์ง์ ํ ํ ์ฌ์ฉํ ์ ์์ |
๋งค๊ฐ ๋ณ์ (parameter) |
๋ฉ์๋ ํธ์ถ ์ '์ ๋ฌํ๋ ๊ฐ'์ ๊ฐ์ง๊ณ ์๋ ์ธ์ (์ง์ญ ๋ณ์์ฒ๋ผ ์ ์ธ๋ ๊ณณ๋ถํฐ ์ํ์ด ๋๋ ๋๊น์ง ์ ํจํจ) |
๊ฐ ๋ณ์์ ์์ฑ์๊ธฐ๋ ์๋์ ๊ฐ๋ค.
- ํด๋์ค๋ณ์ : ํด๋์ค๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ผ๊ฐ ๋
- ์ธ์คํด์ค๋ณ์ : ์ธ์คํด์ค๊ฐ ์์ฑ๋์์ ๋
- ์ง์ญ๋ณ์ / ๋งค๊ฐ๋ณ์ : ์์นํ๊ณ ์๋ ๋ฉ์๋๊ฐ ์ํ๋์์ ๋
Method(Static) ์์ญ
- JVM์ด ๋์ํด์ ํด๋์ค๊ฐ ๋ก๋ฉ๋ ๋ ์์ฑ.
- JVM์ด ์ฝ์ด๋ค์ธ ํด๋์ค์ ์ธํฐํ์ด์ค ๋ํ ๋ฐํ์ ์์ ํ, ๋ฉค๋ฒ ๋ณ์(ํ๋), ํด๋์ค ๋ณ์(Static ๋ณ์), ์์(final), ์์ฑ์(constructor)์ ๋ฉ์๋(method) ๋ฑ์ ์ ์ฅํ๋ ๊ณต๊ฐ.
- Method(Static) ์์ญ์ ์๋ ๊ฒ์ ์ด๋๊ณณ์์๋ ์ ๊ทผ ๊ฐ๋ฅ
- Method(Static) ์์ญ์ ๋ฐ์ดํฐ๋ ํ๋ก๊ทธ๋จ์ ์์๋ถํฐ ์ข
๋ฃ๊ฐ ๋ ๋๊น์ง ๋ฉ๋ชจ๋ฆฌ์ ๋จ์์๋ค.
๊ทธ๋์ static ๋ฉ๋ชจ๋ฆฌ์ ์๋ ๋ฐ์ดํฐ๋ค์ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋ ๋๊น์ง ์ด๋์๋ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
๊ทธ๋ฌ๋ static ๋ฐ์ดํฐ๋ฅผ ๋ฌด๋ถ๋ณํ๊ฒ ๋ง์ด ์ฌ์ฉํ ๊ฒฝ์ฐ ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ ํ์์ด ์ผ์ด๋ ์ ์๊ฒ ๋๋ค.
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๊ฐ ์์๊ฒฝ์ฐ, Method ์์ญ์ ๋ค์ด๊ฐ๋ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
public class Main {
public static int s = 10;
public static void main(String[] args) {
int a = 5;
int b = 5;
int result1 = a + b + Main.s;
System.out.println(result1); // 20
Counter sub = new Counter();
twice(sub);
int result2 = sub.get();
System.out.println(result2); // 100
}
public static void twice(Counter c) {
c.plus(10);
c.plus(20);
}
}
class Counter {
public int state = 50;
public final int count = 20;
public int get() {
return state + count;
}
public void plus(int n) {
state += n;
}
}

- ํด๋์ค ๋ณ์(static)์ ๋ฉ์๋๋ ๋ฌด์กฐ๊ฑด Method ์์ญ์ ์ ์ฌ
- ์ผ๋ฐ ์ธ์คํด์ค ๋ณ์์ธ Counter ํด๋์ค์ ๋ณ์
state๊ทธ๋ฆฌ๊ณcount์ final ํค์๋๊ฐ ๋ถ์์์๋ Method ์์ญ์ ๋ค์ด๊ฐ์ง ์์ (Heap ์ ๋ค์ด๊ฐ)
Stack ์์ญ
- ๋ฉ์๋ ๋ด์์ ์ ์ํ๋ ๊ธฐ๋ณธ ์๋ฃํ์ ํด๋น๋๋ ์ง์ญ๋ณ์์ ๋ฐ์ดํฐ ๊ฐ์ด ์ ์ฅ๋๋ ๊ณต๊ฐ
- ๋ฉ์๋๊ฐ ํธ์ถ๋ ๋ ์คํ ์์ญ์ ์คํ ํ๋ ์์ด ์๊ธฐ๊ณ ๊ทธ์์ ๋ฉ์๋๋ฅผ ํธ์ถ
- primitive ํ์ ์ ๋ฐ์ดํฐ(int, double, byte, long, boolean ๋ฑ) ์ ํด๋น๋๋ ์ง์ญ๋ณ์, ๋งค๊ฐ ๋ณ์ ๋ฐ์ดํฐ ๊ฐ์ด ์ ์ฅ
- ๋ฉ์๋๊ฐ ํธ์ถ ๋ ๋ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋๊ณ ์ข ๋ฃ๋๋ฉด ๋ฉ๋ชจ๋ฆฌ์์ ์ฌ๋ผ์ง
- Stack ์ ํ์ ์ ์ถ LIFO(Last-In-First-Out) ์ ํน์ฑ์ ๊ฐ์ง๋ฉฐ, ์ค์ฝํ(Scope) ์ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ฉด ์คํ ๋ฉ๋ชจ๋ฆฌ์์ ์ฌ๋ผ์ง๋ค.
[ ์คํ ํ๋ ์(stack frame) ]
ํ๋์ ๋ฉ์๋์ ํ์ํ ๋ฉ๋ชจ๋ฆฌ ๋ฉ์ด๋ฆฌ๋ฅผ ๋ฌถ์ด์ ์คํ ํ๋ ์(Stack Frame)์ด๋ผ๊ณ ํ๋ค.
ํ๋์ ๋ฉ์๋๋น ํ๋์ ์คํ ํ๋ ์์ด ํ์ํ๋ฉฐ, ๋ฉ์๋๋ฅผ ํธ์ถํ๊ธฐ ์ง์ ์คํํ๋ ์์ ์๋ฐ Stack์ ์์ฑํ ํ ๋ฉ์๋๋ฅผ ํธ์ถํ๊ฒ ๋๋ค.
์คํ ํ๋ ์์ ์์ด๋ ๋ฐ์ดํฐ๋ ๋ฉ์๋์ ๋งค๊ฐ๋ณ์, ์ง์ญ๋ณ์, ๋ฆฌํด๊ฐ ๋ฑ์ด ์๋ค.
๋ง์ผ ๋ฉ์๋ ํธ์ถ ๋ฒ์๊ฐ ์ข ๋ฃ๋๋ฉด ์คํ์์ ์ ๊ฑฐ๋๋ค.
์ฒ์์ ์ํ์ฝ๋์์ public static void main(String[] agrs) ๋ผ๋ ๋ฉ์ธ ๋ฉ์๋๊ฐ ์คํ๋๋ฉด ์คํ ์์ญ์ ์คํ ํ๋ ์์ด ์์ด๊ณ ์์ ์ง์ญ๋ณ์์ ๋งค๊ฐ๋ณ์๊ฐ ๋ด๊ธฐ๊ฒ ๋๋ค.

- ๋ฉ์๋์ ๋งค๊ฐ๋ณ์
args์ ๋ฉ์๋ ๋ธ๋ก ์์ ์ง์ญ๋ณ์a,b,result1์ด ๋ด์์ง๋ค.
Heap ์์ญ
- JVM์ด ๊ด๋ฆฌํ๋ ํ๋ก๊ทธ๋จ ์์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํด ๋ฐํ์ ์ ๋์ ์ผ๋ก ํ ๋นํ์ฌ ์ฌ์ฉํ๋ ์์ญ
- ์ฐธ์กฐํ(Reference Type) ๋ฐ์ดํฐ ํ์ ์ ๊ฐ๋ ๊ฐ์ฒด(์ธ์คํด์ค), ๋ฐฐ์ด ๋ฑ์ด ์ ์ฅ ๋๋ ๊ณต๊ฐ
- ๋จ, Heap ์์ญ์ ์๋ ์ค๋ธ์ ํธ๋ค์ ๊ฐ๋ฆฌํค๋ ๋ ํผ๋ฐ์ค ๋ณ์๋ stack์ ์ ์ฌ
- Heap ์์ญ์ Stack ์์ญ๊ณผ ๋ค๋ฅด๊ฒ ๋ณด๊ด๋๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํธ์ถ์ด ๋๋๋๋ผ๋ ์ญ์ ๋์ง ์๊ณ ์ ์ง๋๋ค.
๊ทธ๋ฌ๋ค ์ด๋ค ์ฐธ์กฐ ๋ณ์๋ Heap ์์ญ์ ์๋ ์ธ์คํด์ค๋ฅผ ์ฐธ์กฐํ์ง ์๊ฒ ๋๋ค๋ฉด, GC(๊ฐ๋น์ง ์ปฌ๋ ํฐ)์ ์ํด ๋ฉ๋ชจ๋ฆฌ์์ ์ฒญ์๋๋ค. - stack์ ์ค๋ ๋ ๊ฐฏ์๋ง๋ค ๊ฐ๊ฐ ์์ฑ๋์ง๋ง, heap์ ๋ช๊ฐ์ ์ค๋ ๋๊ฐ ์กด์ฌํ๋ ์๊ด์์ด ๋จ ํ๋์ heap ์์ญ๋ง ์กด์ฌ
1. ์์ฑ์ new Counter() ๋ฅผ ํธ์ถํ๋ค.
- ์์ฑ์๋ฅผ ํธ์ถํ๋ฉด heap ์์ญ์ Counter ํด๋์ค ์ธ์คํด์ค ๋ณ์๋ค์ด ์ ์ฅ๋๊ฒ ๋๊ณ , stack ์์ญ์ ์ง์ญ๋ณ์ sub ์ ์ฃผ์๊ฐ์ผ๋ก ์ฐ๊ฒฐ๋๊ฒ ๋๋ค.

2. twice(sub) ๋ฉ์๋๋ฅผ ์คํํ๋ค.
- ์๋ก์ด ๋ฉ์๋๋ฅผ ์คํํ๋ ๊ฒ์ด๋, stack ์์ญ์ ์๋ก์ด ์คํ ํ๋ ์์ด ์๊ธฐ๊ฒ ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ ์๊ท๋จผํธ๋ก ํด๋์ค๋ฅผ ์ ๋ฌํ์๊ธฐ ๋๋ฌธ์
twice()์ ๋งค๊ฐ๋ณ์c๋ ์ฃผ์๊ฐ์ผ๋ก ๊ฐ์ ํ ์์ญ์ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค.

3. ๊ฐ์ฒด์ plus() ๋ฉ์๋๋ฅผ ์คํํ๋ค.
- ๊ฐ์ฒด Counter์ ์ ์๋
plus()๋ฉ์๋๋ฅผ ํธ์ถํ๊ฒ ๋๋๋ฐ, ์ด ์ญ์ ๋ฉ์๋ ์ด๋ฏ๋ก ์คํ ์์ญ์ ์๋ก์ด ์คํ ํ๋ ์์ผ๋ก ์์ฑ๋๊ฒ ๋๋ค. - ๋ค๋ง ์ฌ๊ธฐ์
this๋ผ๋ ์๋ฌต์ ์ธ ๋ณ์๊ฐ ์๋ ์์ฑ๋๊ฒ ๋๋๋ฐ, ์ดthis๋ณ์๋ ์๋์ผ๋ก ํ ์์ญ์ ์๋ Counter ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค. - ๋ฐ๋ผ์
plus()๋ฉ์๋ ์์ ์ฝ๋state += n์ด ๋์ํ๋ฉด์ ํ ์์ญ์ ์๋ ์ธ์คํด์ค ๋ณ์state๊ฐ ๊ฐ์ด ๋ณํ๊ฒ ๋๋ค.

4. ๊ฐ์ฒด์ state ์ธ์คํด์ค ๋ณ์๋ฅผ ๊ฐ์ ธ์ค๋ get() ๋ฉ์๋๋ฅผ ํธ์ถํ๋ค.
- ๋ชจ๋ ์คํ๋์ด ๋ณผ์ผ์ด ๋๋
plus()์คํ ํ๋ ์์ ์ ๊ฑฐ ๋๋ค. - ๋ง์ฐฌ๊ฐ์ง๋ก
sub๊ฐ์ฒด๋ณ์์ ๋ฉ์๋get()์ ํธ์ถํ๋ฉด ์คํ ์์ญ์ ์๋ก์ด ์คํ ํ๋ ์์ด ์๊ธฐ๊ณ ,this๋ณ์๊ฐ ํ ์์ญ์ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ํ ์์ญ์ ๋ณ์๋ฅผ ๋ฐํํ๊ฒ ๋๋ค. - ๋ง์ง๋ง์ผ๋ก ํ ์ผ์ ๋ง์น
get()์คํ ํ๋ ์์ ์คํ ์์ญ์์ ์ ๊ฑฐ๋๊ณ , main ์คํ ํ๋ ์์result2์ง์ญ ๋ณ์๊ฐ ์ถ๊ฐ๋๋ค.


์ด ์์ ์์ ๊ฐ์กฐ๋๋ ๋ถ๋ถ์ ํธ์ถ๋๋ ๋ฉ์๋๊ฐ ํ๋ผ๋ฏธํฐ๋ก ๊ฐ์ฒด๊ฐ์ ์ ๋ฌ๋ฐ์ ๊ฐ์ฒด์ ์ํ๋ฅผ ๋ณ๊ฒฝํ๊ฒ ๋๋ฉด, ๋ฉ์๋ ์ข ๋ฃ(์คํ ์ ๊ฑฐ) ์ดํ์๋ ํ ์์ญ์ ์๋ ๊ฐ์ฒด์ ์ํ๋ ์ญ ์ ์ง๋๋ค๋ ์ ์ด๋ค.
5. ๋ง์ง๋ง ์ฝ๋๊ฐ ์คํ๋๋ฉด main ์คํ ํ๋ ์์ ์คํ ์์ญ์์ ์ ๊ฑฐ๋๋ค.
- ์คํ ์์ญ์ ๋ฉ์๋์ ๋์ ์๋ฆฌ๋ ๋ซ๋ ์ค๊ดํธ
}๋ฅผ ๋ง๋๋ฉด ์๋์ผ๋ก ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐ๋๋ค. - ๊ทธ๋ฌ๋ ํ ์์ญ์๋ ์ฌ์ ํ ๊ฐ์ฒด ๋ฐ์ดํฐ๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ์์ฃผ๋๊ฒ ๋๋ค.

6. ๊ฐ๋น์ง ์ปฌ๋ ํฐ(GC)๊ฐ ํ ์์ญ์ ์ฒญ์ํ๋ค.
- ๊ฐ๋น์ง ์ปฌ๋ ํฐ๋ ํ ์์ญ์ ์ฐธ์กฐ๋์ง ์๊ณ ๋จ์๋ฒ๋ฆฐ ๊ณ ์ ๊ฐ์ฒด๋ค์ ์๋ณํด ํ ์์ญ์ ์ฒญ์ ํด์ฃผ๋ ์ญํ ์ ํ๋ค.
- ์ถ๊ฐ๋ก ์ฝ๋ ์คํ์ด ๋ชจ๋ ๋๋๋ฉด Method(Static) ์์ญ๋ ๋น์์ง๊ฒ ๋๋ค.

ํ ๊ณผ ์คํ ๋ฉ๋ชจ๋ฆฌ์ ์ฐจ์ด์
์ด์ ๋ฆฌ ๊ฒธ ๋ง์ง๋ง์ผ๋ก heap ๊ณผ stack ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ๋ํ ๊ฐ๋จํ ์ฐจ์ด์ ์ ๋์ดํด ๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.

- ํ ๋ฉ๋ชจ๋ฆฌ๋ ์ ํ๋ฆฌ์ผ์ด์
์ ๋ชจ๋ ๋ถ๋ถ์์ ์ฌ์ฉ๋๋ฉฐ, ๋ฐ๋ฉด์ ์คํ ๋ฉ๋ชจ๋ฆฌ๋ ํ๋์ ์ค๋ ๋๊ฐ ์คํ๋ ๋ ์ฌ์ฉ.
๊ทธ๋์ ํ ๊ณผ ๋ฉ์๋ ๊ณต๊ฐ์ ์ ์ฅ๋ ๊ฐ์ฒด๋ ์ด๋์๋ ์ง ์ ๊ทผ์ด ๊ฐ๋ฅํ์ง๋ง, ์คํ ๋ฉ๋ชจ๋ฆฌ๋ ๋ค๋ฅธ ์ค๋ ๋๊ฐ ์ ๊ทผํ ์ ์๋ค. - ์ธ์ ๋ ์ง ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ฉด ํญ์ ํ ๊ณต๊ฐ์ ์ ์ฅ๋๋ฉฐ, ์คํ ๋ฉ๋ชจ๋ฆฌ๋ ํ ๊ณต๊ฐ์ ์๋ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐ๋ง ํ๋ค.
์ฆ, ์คํ ๋ฉ๋ชจ๋ฆฌ๋ primitive ํ์ ์ ์ง์ญ๋ณ์์ ํ ๊ณต๊ฐ์ ์๋ ๊ฐ์ฒด ์ฐธ์กฐ ๋ณ์๋ง ๊ฐ๊ณ ์๋ค. - ์คํ๋ฉ๋ชจ๋ฆฌ์ ์๋ช ์ฃผ๊ธฐ๋ ๋งค์ฐ ์งง์ผ๋ฉฐ, ํ ๋ฉ๋ชจ๋ฆฌ๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ์์๋ถํฐ ๋๊น์ง ์ด์๋จ๋๋ค.
- ์๋ฐ ์ฝ๋๋ฅผ ์คํํ ๋ ๋ฐ๋ก
-Xms๊ณผ-Xmx์ต์ ์ ์ฌ์ฉํ๋ฉด ํ ๋ฉ๋ชจ๋ฆฌ์ ์ด๊ธฐ ์ฌ์ด์ฆ์ ์ต๋ ์ฌ์ด์ฆ๋ฅผ ์กฐ์ ํ ์ ์๋ค. - ์คํ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๊ฐ๋์ฐจ๋ฉด ์๋ฐ์์๋ java.lang.StackOverFlowError๋ฅผ ๋ฐ์.
ํ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๊ฐ๋์ฐจ๋ฉด java.lang.OutOfMemoryError : Java Heap Space ์๋ฌ๋ฅผ ๋ฐ์ - ์คํ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ด์ฆ๋ ํ ๋ฉ๋ชจ๋ฆฌ์ ๋น๊ตํ์ ๋ ๋งค์ฐ ์ ๋ค. ํ์ง๋ง ์คํ ๋ฉ๋ชจ๋ฆฌ๋ ๊ฐ๋จํ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๋ฐฉ๋ฒ(LIFO)๋ฅผ ์ฌ์ฉํ๋ฏ๋ก ํ ๋ฉ๋ชจ๋ฆฌ๋ณด๋ค ๋น ๋ฅด๋ค.
์ด ๊ธ์ด ์ข์ผ์ จ๋ค๋ฉด ๊ตฌ๋ & ์ข์์
์ฌ๋ฌ๋ถ์ ๊ตฌ๋
๊ณผ ์ข์์๋
์ ์์๊ฒ ํฐ ํ์ด ๋ฉ๋๋ค.