๐ ์๋ฃ๊ตฌ์กฐ - Java ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ(Stack, Heap)
์๋ฐ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ
์ถ์ฒ : ์ด๋ฏธ์ง
์๋ฐ ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ฉด JVM(์๋ฐ ๊ฐ์ ๋จธ์ )์ OS๋ก๋ถํฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋น ๋ฐ๊ณ ๊ทธ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฉ๋์ ๋ฐ๋ผ์ ์ฌ๋ฌ ์์ญ์ผ๋ก ๋๋์ด ๊ด๋ฆฌํ๋ค.
JVM
์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ(Runtime Data Area)๋ ํฌ๊ฒ Method(Static) ์์ญ, Stack ์์ญ, Heap ์์ญ์ผ๋ก ๊ตฌ๋ถ๋๊ณ ๋ฐ์ดํฐ ํ์
(์๋ฃํ)์ ๋ฐ๋ผ ๊ฐ ์์ญ์ ๋๋ ์ ํ ๋น๋๊ฒ ๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
public int solution void main(String[] args) { // ๋งค๊ฐ๋ณ์
int answer = 10; // ์ง์ญ๋ณ์
}
}
public calss Counter {
private int state = 0; // ์ธ์คํด์ค ๋ณ์
public static int gage = 100; // ํด๋์ค ๋ณ์
public int get() {
return state;
}
}
๋ณ์๋ช | ์ ์ธ ์์น | ์ค๋ช |
---|---|---|
ํด๋์ค ๋ณ์ | ํด๋์ค ์์ญ | ํด๋์ค ์์ญ์์ ํ์ ์์ static์ด ๋ถ๋ ๋ณ์, ๊ฐ์ฒด๋ฅผ ๊ณต์ ํ๋ ๋ณ์๋ก ์ฌ๋ฌ ๊ฐ์ฒด์์ ๊ณตํต์ผ๋ก ์ฌ์ฉํ๊ณ ์ถ์ ๋ ์ ์ |
์ธ์คํด์ค ๋ณ์ | ํด๋์ค ์์ญ | ํด๋์ค ์์ญ์์ static์ด ์๋ ๋ณ์, ๊ฐ๋ณ์ ์ธ ์ ์ฅ ๊ณต๊ฐ์ผ๋ก ๊ฐ์ฒด/์ธ์คํด์ค๋ง๋ค ๋ค๋ฅธ ๊ฐ ์ ์ฅ ๊ฐ๋ฅ |
์ง์ญ ๋ณ์ | ๋ฉ์๋ ์์ญ | ๋ฉ์๋ ๋ด์์ ์ ์ธ๋๊ณ ๋ฉ์๋ ์ํ์ด ๋๋๋ฉด ์๋ฉธ๋๋ ๋ณ์, ์ด๊น๊ฐ์ ์ง์ ํ ํ ์ฌ์ฉํ ์ ์์ |
๋งค๊ฐ ๋ณ์ | ๋ฉ์๋ ์์ญ | ๋ฉ์๋ ํธ์ถ ์ โ์ ๋ฌํ๋ ๊ฐโ์ ๊ฐ์ง๊ณ ์๋ ์ธ์ |
๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ
์ ํ๋ฆฌ์ผ์ด์ ์ ํ ๋น๋๋ ๋ฉ๋ชจ๋ฆฌ๋ ๋ด๋ถ์ ์ผ๋ก ์ฌ๋ฌ ์์ญ์ผ๋ก ๋๋จ
stack ๋ฉ๋ชจ๋ฆฌ : ํจ์๋ ๋ฉ์๋์ ์ง์ญ ๋ณ์(local variable)์ ๋งค๊ฐ ๋ณ์(parameter)๊ฐ ์ ์ฅ๋จ. ํจ์๋ ๋ฉ์๋๊ฐ ํธ์ถ๋ ๋๋ง๋ค ์คํ ํ๋ ์(stack frame)์ด ์์.
heap ๋ฉ๋ชจ๋ฆฌ : ๊ฐ์ฒด๊ฐ ์ ์ฅ๋จ.
Method(Static) ์์ญ
JVM์ด ๋์ํด์ ํด๋์ค๊ฐ ๋ก๋ฉ๋ ๋ ์์ฑ
JVM์ด ์ฝ์ด๋ค์ธ ํด๋์ค์ ์ธํฐํ์ด์ค์ ๋ํ ๋ฐํ์ ์์ ํ, ๋ฉค๋ฒ ๋ณ์(ํ๋), ํด๋์ค ๋ณ์(Static ๋ณ์), ์์(final), ์์ฑ์(constructor), ๋ฉ์๋(method) ๋ฑ์ ์ ์ฅํ๋ ๊ณต๊ฐ
Method(Static) ์์ญ์ ์๋ ๊ฒ์ ์ด๋๊ณณ์์๋ ์ ๊ทผ ๊ฐ๋ฅ
Method(Static) ์์ญ์ ๋ฐ์ดํฐ๋ ํ๋ก๊ทธ๋จ์ ์์๋ถํฐ ์ข ๋ฃ๊ฐ ๋ ๋๊น์ง ๋ฉ๋ชจ๋ฆฌ์ ๋จ์์์.
Stack ์์ญ
๊ธฐ๋ณธ ์๋ฃํ, ์ง์ญ๋ณ์, ๋งค๊ฐ๋ณ์๊ฐ ์ ์ฅ๋๋ ๋ฉ๋ชจ๋ฆฌ
๋ฉ์๋ ๋ด๋ถ์ ๊ธฐ๋ณธ ์๋ฃํ์ ํด๋นํ๋ ๋ณ์ ์ ์ฌ
Heap
์์ญ์ ์์ฑ๋ ๋ฐ์ดํฐ์ ์ฐธ์กฐ ๊ฐ์ด ํ ๋น๋จ๋ฉ์๋๊ฐ ํธ์ถ๋ ๋ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น, ๋ฉ์๋ ์ข ๋ฃ์ ๋ฉ๋ชจ๋ฆฌ์์ ์ญ์ ๋จ.
์๋ฃ๊ตฌ์กฐ
Stack
๊ตฌ์กฐ,LIFO(Last In First Out)
๊ฐ
Thread
๋ง๋ค ์์ ๋ง์Stack
์ ๊ฐ์งThread
๋ ๋ค๋ฅธThread
์ ์ ๊ทผํ ์ ์์ผ๋static
,Heap
์์ญ์ ๊ณต์ ํ์ฌ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
Heap ์์ญ
JVM
์ด ๊ด๋ฆฌํ๋ ํ๋ก๊ทธ๋จ ์์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํด ๋ฐํ์ ์ ๋์ ์ผ๋ก ํ ๋นํ์ฌ ์ฌ์ฉํ๋ ์์ญ ์ฐธ์กฐํ(Reference Type) ๋ฐ์ดํฐ ํ์ ์ ๊ฐ๋ ๊ฐ์ฒด(์ธ์คํด์ค), ๋ฐฐ์ด ๋ฑ์ด ์ ์ฅ๋๋ ๊ณต๊ฐ๋จ
Heap
์์ญ์ ์๋ ์ค๋ธ์ ํธ๋ค์ ๊ฐ๋ฆฌํค๋ ๋ ํผ๋ฐ์ค ๋ณ์๋stack
์ ์ ์ฌHeap
์์ญ์Stack
์์ญ๊ณผ ๋ค๋ฅด๊ฒ ๋ณด๊ด๋๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํธ์ถ์ด ๋๋๋๋ผ๋ ์ญ์ ๋์ง ์๊ณ ์ ์ง๋จ. ๊ทธ๋ฌ๋ค ์ด๋ค ์ฐธ์กฐ ๋ณ์๋Heap
์์ญ์ ์๋ ์ธ์คํด์ค๋ฅผ ์ฐธ์กฐํ์ง ์๊ฒ ๋๋ค๋ฉด,GC
(๊ฐ๋น์ง ์ปฌ๋ ํฐ)์ ์ํด ๋ฉ๋ชจ๋ฆฌ์์ ์ฒญ์๋จ.Stack
์ ์ค๋ ๋ ๊ฐฏ์๋ง๋ค ๊ฐ๊ฐ ์์ฑ๋์ง๋งheap
์ ๋ช๊ฐ์ ์ค๋ ๋๊ฐ ์กด์ฌํ๋ ์๊ด์์ด ๋จ ํ๋์heap
์์ญ๋ง ์กด์ฌ
๊ทธ๋ฆผ ์ค๋ช
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MemoryExample {
public static void main(String[] args) {
int x = 10; // ๊ธฐ๋ณธ ํ์
(์คํ)
String name = "John"; // ์ฐธ์กฐ ํ์
(ํ)
Person person1 = new Person("Alice", 25); // ๊ฐ์ฒด ์์ฑ (ํ)
Person person2 = person1; // ์ฐธ์กฐ ๋ณต์ฌ
}
}
class Person {
String name; // ์ฐธ์กฐ ํ์
ํ๋
int age; // ๊ธฐ๋ณธ ํ์
ํ๋
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
์คํ(Stack) ๋ฉ๋ชจ๋ฆฌ ํน์ฑ
args
: ๋ฉ์ธ ๋ฉ์๋์ ์ธ์x
: ์ซ์ 10name
: ๋ฌธ์์ด์ ๊ฐ๋ฆฌํค๋ ์ฃผ์person1
,person2
: ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ ์ฐธ์กฐ๊ฐ- ํน์ง : ํ์ ์ ์ถ(LIFO) ๊ตฌ์กฐ, ์ ์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
ํ(Heap) ๋ฉ๋ชจ๋ฆฌ ํน์ฑ
- โJohnโ์ด๋ผ๋ ๋ฌธ์์ด ๊ฐ์ฒด
- Person ๊ฐ์ฒด (name๊ณผ age ๊ฐ์ง๊ณ ์์)
- ํน์ง : ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น, ๊ฐ๋น์ง ์ปฌ๋ ํฐ ๊ด๋ฆฌ