โ๏ธ ๊ธฐ๋ณธ ์๋ฃํ๊ณผ ์ฐธ์กฐ ์๋ฃํ์ ๊ณต๋ถํ๊ณ ๋๋ Stack๊ณผ Heap ๋ฉ๋ชจ๋ฆฌ์ ๋ํด์๋ ๊ถ๊ธํด์ก๋ค. ๋ฌด์๋ณด๋ค ์ฒซ ๋ฉํ ๋ง ์๊ฐ์ ์ด ๋์ ๋ํ ์ค๋ช ์ ์ ๋๋ก ํ์ง ๋ชปํด ๋ณต์ต์ ํ๊ธด ํ์ด์ผ ํ๋ค.
๋, ์ค๋ฌด์์ ์ด์ ๋ํ ๊ฐ๋ ์ด ์ ๋๋ก ์กํ์ง ์์ ์ฌ๋ฌ ๋ฒ ์ค์๋ฅผ ๊ฒฝํํ ์ ์ด ์๋ค. ์์ผ๋ก ์ด๋ฐ ์ค์๋ฅผ ๋ค์ ๋ํ์ดํ์ง ์๊ธฐ ์ํด ๋๋ต์ ์ผ๋ก๋ง ํ์ ํ๊ณ ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ์์๋ณด์!
Stack Memory
- ๊ธฐ๋ณธ ์๋ฃํ์ผ๋ก ์ ์ธ๋ ๋ณ์๋ ๊ฐ๊ณผ ํจ๊ป ํ ๋น๋๋ค.
- ์ฐธ์กฐ ์๋ฃํ์ ํ ๋น๋ Heap Memory์ ์ฐธ์กฐ๊ฐ๊ณผ ํ ๋น๋๋ค.
- ๊ฐ ์ค๋ ๋๋ ๊ฐ์์ Stack Memory ์์ญ์ ๊ฐ์ง๋ค.
- ์ง์ญ ๋ณ์, ๋งค๊ฐ ๋ณ์์ ์๋ช ์ฃผ๊ธฐ๋ ์์ ์ด ์ํ ๊ณณ์ ์ค์ฝํ๊ฐ ์คํ๋๋ฉด ์ฌ๋ผ์ง๋ค.
public class StackMemoryTest {
public static int changeStayus(int param) {
int tmp = param * 10;
int result = tmp / 2;
return result;
}
public static void main(String[] args) {
int value = 10;
value = changeStayus(value);
System.out.println(value);
}
}
์ ์ฝ๋๋ฅผ ์ดํด๋ณด์.
main() ๋ฉ์๋์ ์ ์ธ๋ value ๋ณ์๋ 10 ์ด๋ผ๋ ๊ฐ์ด Stack Memory์ ํ ๋น๋๋ค. ๊ทธ ์ดํ์ changeStatus() ๋ฉ์๋๋ฅผ ํธํํ๋ฉด์ ์ธ์๊ฐ์ผ๋ก value๋ฅผ ๋๊ฒจ์ฃผ๊ฒ ๋๋๋ฐ, ์ฐธ์กฐ ์๋ฃํ์ฒ๋ผ ๊ฐ์ ์ฐธ์กฐํ์ง ์๊ณ changeStatus()์ ๋งค๊ฐ ๋ณ์ param์ ํด๋น ๊ฐ์ด ๋ณต์ฌ๋์ด Stack Memory์ ํ ๋น๋๋ค. (๊ทธ๋ฆผ์ผ๋ก ๊ทธ๋ฆฌ๊ณ ์ถ์๋ฐ ํ์ ๋ค์ณ์ ๊ทธ๋ฆด ์๊ฐ ์๋ค.)
์ด์ changeStatus() ๋ฉ์๋๋ก ์ด๋ํ์ฌ Stack Memory์ ์ด๋ค ๊ฐ์ด ์ ์ฅ๋๋์ง ์์๋ณด์. changeStatus() ๋ฉ์๋ ๋ด์์ ์ ์ธ๋ tmp ๋ณ์๊ฐ Stack Memory์ ํ ๋น๋๊ณ , result ๋ณ์๊ฐ ์ ์ธ๋๋ฉฐ Sack Memory์ ํ ๋น๋๋ค. ์ด์ result ๋ณ์๊ฐ main() ๋ฉ์๋์ value ๋ณ์์ ๋ฆฌํด๋๋ฉด์ changeStatus() ๋ฉ์๋์์ ์ ์ธ๋ ๋งค๊ฐ ๋ณ์ param๊ณผ ์ง์ญ ๋ณ์ tmp, result์ ํด๋น ๋ฉ์๋์ ๋ง์ง๋ง ์ค์ฝํ๊ฐ ์คํ๋๋ฉด์ Stack Memory์์ pop๋์ด ์ฌ๋ผ์ง๋ค.
main() ๋ฉ์๋์ value ๋ณ์์ ๊ฐ์ changeStatus() ๋ฉ์๋๊ฐ ์ข
๋ฃ๋๋ฉด์ ๋ฆฌํดํ ๊ฐ์ผ๋ก ์ด๊ธฐํ๋๊ณ ํด๋น ๋ณ์๋ System.out.println()์ ์ํด ์ฝ์์ฐฝ์ ์ถ๋ ฅ๋๊ณ main() ๋ฉ์๋์ ๋ง์ง๋ง ์ค์ฝํ๊ฐ ์คํ๋๋ฉด์ Stack Memory์ ๋ง์ง๋ง์ผ๋ก ํ ๋น๋ value ๋ณ์๋ pop๋์ด ์ฌ๋ผ์ง๋ค.
Heap Memory
- ์๋ช ์ฃผ๊ธฐ๊ฐ ๊ธด ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋๋ค.
- ๋ชจ๋ ์ฐธ์กฐ ์๋ฃํ์ ํด๋น ์์ญ์ ํ ๋น๋๋ฉฐ, ์ด์ ํด๋นํ๋ ์ฃผ์๊ฐ์ด ๋ ํผ๋ฐ์ค ๋ณ์์ ํจ๊ป Stack Memory์ ์ ์ฅ๋๋ค.
- ์ค๋ ๋์ ๊ฐ์์๋ ๊ด๊ณ์์ด ํ๋์ Heap Memory๋ง ์กด์ฌํ๋ค.
public class HeapMemoryTest {
public static void main(String[] args) {
int value = 10;
String hello = "hello";
HeapMemoryTest heapMemoryTest = new HeapMemoryTest();
}
}
์์ ์ฝ๋๋ฅผ ์ดํด๋ณด๋ฉด, value ๋ณ์๋ Stack Memory์ ๊ฐ๊ณผ ๋ณ์๊ฐ ํ ๋น๋์๊ณ , hello ๋ณ์์ heapMemoryTest ๋ณ์๋ Heap Memory(hello ๋ณ์๋ Constant Pool) ํ ๋น๋์ด ํด๋น ์ฃผ์๊ฐ๊ณผ ๋ณ์๊ฐ Staack Memory์ ํ ๋น๋ ๊ฒ์ ์ง๋ ์๊ฐ ๊ณต๋ถํ ๊ฒ์ ํตํด์ ์ ์ ์๋ค.
์ด ๋, ์ฐธ์กฐ ์๋ฃํ๋ค์ Pass By Reference ๋ผ๋ ํน์ฑ์ด ์๋๋ฐ, ์ด๋ ๊ธฐ๋ณธ ์๋ฃํ๊ณผ ๋ค๋ฅด๋ค. ๊ธฐ๋ณธ ์๋ฃํ์ ํน์ ๋ณ์๊ฐ ์ด๋ค ๋ฉ์๋์ ์ธ์๋ก ์ ๋ฌ๋ ๋ ๊ฐ์ด ๋ณต์ฌ๋์ด ํธ์ถ๋ ๋ฉ์๋์์ ์ธ์๋ก ๋ฐ์ ๋งค๊ฐ ๋ณ์์ ์ด๋ค ์ง์ ํด๋ ์๋ ์๋ ๋ณ์๋ ๊ฐ์ด ๋ณํ์ง ์๋๋ค.
ํ์ง๋ง ์ฐธ์กฐ ์๋ฃํ์ ๊ฒฝ์ฐ ํด๋น ์ฐธ์กฐ ๋ณ์๋ฅผ ์ด๋ค ๋ฉ์๋์ ์ธ์๋ก ์ ๋ฌํ์ฌ ํด๋น ๋ฉ์๋ ๋ด์์ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ๋งค๊ฐ ๋ณ์์ ๊ฐ์ ์์ ํ๋ค๋ฉด, ์๋ ์๋ ์ฐธ์กฐ ๋ณ์์ ๊ฐ๋ ๋ณํํ๋ค. ์ด๋ ๊ธฐ๋ณธ ์๋ฃํ์ฒ๋ผ ๊ฐ์ ๋ณต์ฌํ๋ ๊ฒ์ด ์๋๋ผ, Heap Memory์ ์ ์ฅ๋์ด ์๋ ๊ฐ์ ํจ๊ป ์ฐธ์กฐํ๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๊ธฐ์กด์ ์ฐธ์กฐ ๋ณ์๊ฐ ์ด๋ ํ ๋ฉ์๋์ ์ธ์๋ก ์ ๋ฌ๋๊ณ , ๊ทธ ๋ฉ์๋์์ ๊ฐ์ด ๋ณ๊ฒฝ๋๋ฉด ๊ธฐ์กด์ ์ฐธ์กฐ ๋ณ์์ ๊ฐ์ ์๋ฌด๋ ์ฐธ์กฐํ์ง ์์ ์ํ๋ก Heap Memory์ ๋จ๊ฒ ๋๋ค. ์ด๋ฌํ ์ฐ๋ ๊ธฐ ๊ฐ์ Garbage Collector๊ฐ ์์์ ์ ๋ฆฌ๋ฅผ ํด์ค๋ค.
String, Wrapper Class
๋ค๋ง ๋ชจ๋ ์ฐธ์กฐ ์๋ฃํ์ด ์ธ์๋ก ์ ๋ฌ๋ ๋ ๋ชจ๋ ๊ฐ์ ๊ฐ์ ์ฐธ์กฐํ๋ ๊ฒ์ ์๋๋ค. String๊ณผ ๊ธฐ๋ณธ ์๋ฃํ์ Wrapper ํด๋์ค๋ค์ ๋ถ๋ณํ๋ ๊ฐ์ ๊ฐ์ง๋ ๊ท์น ๋๋ฌธ์ immutable ํ ํน์ง์ ๊ฐ์ง๋ค. ๋๋ฌธ์ ํด๋น ๋ณ์๋ค์ ์ด๋ ํ ๋ฉ์๋์ ์ธ์๋ก ์ ๋ฌ๋์ด ๋ฉ์๋ ๋ด์์ ๊ฐ์ด ๋ณ๊ฒฝ๋์ด๋ ์๋ ์๋ ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
public class HeapMemoryTest {
public static void main(String[] args) {
String str = "hello";
Integer integer = 2021;
System.out.println("str = " + str);
System.out.println("integer = " + integer);
changeStatus(str, integer);
System.out.println("str = " + str);
System.out.println("integer = " + integer);
}
public static void changeStatus(String strParam, Integer intParam) {
String tmpStr = strParam + " world!";
Integer tmpInt = intParam + intParam;
System.out.println("tmpStr = " + tmpStr);
System.out.println("tmpInt = " + tmpInt);
}
}
/*
str = hello
integer = 2021
tmpStr = hello world!
tmpInt = 4084441
str = hello
integer = 2021
*/
์ ์ฝ๋๋ฅผ ๋ณด๋ฉด ์ ์ ์๋ฏ, String๊ณผ Integer ํด๋์ค๋ ์ฐธ์กฐ ์๋ฃํ์ด์ง๋ง ๋ง์น ๊ธฐ๋ณธ ์๋ฃํ์ฒ๋ผ ์๋ํ๋ค. ์ด๋ ๋ชจ๋ Wrapper ํด๋์ค์ final ์ ๊ทผ ์ ์ด์๊ฐ ์ ์ธ๋์๊ธฐ ๋ ๋ฌธ์ธ๋ฐ, JDK 5 ๋ฒ์ ๋ถํฐ AutoBoxing/UnBoxing์ ์ง์ํ๋ฉด์ Wrapper ํด๋์ค์ ์ธ์คํด์ค๊ฐ ๋ถ๋ณํ์ง ์๋๋ค๋ ์์น์ ์ด๊ธ๋๋ ๊ฒ๊ณผ ๋ฉ๋ชจ๋ฆฌ์ CPU ๋ญ๋น ๋ฑ ๋ค์ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํจ์ด๋ค.
์ฐธ๊ณ ์ฌ์ดํธ
Why wrapper classes in Java are final?
Just simply as it sounds. I need to extend their functionality and I cannot. Why are they defined as final? Example: class MyInteger extends Integer { }
stackoverflow.com
์๋ฐ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ - ์คํ & ํ
๊ฐ์ Java ์์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ ์ด๋ป๊ฒ ์ด๋ฃจ์ด์ง๋์ง ์์๋ณด๊ธฐ ์ํจ. Stack ๊ณผ Heap ์์ญ ๊ฐ ์ญํ ์ ๋ํด ์์๋ณธ๋ค. ๊ฐ๋จํ ์ฝ๋์์ ์ ํจ๊ป ์ค์ ์ฝ๋์์ ์ด๋ป๊ฒ Stack ๊ณผ Heap ์์ญ์ด ์ฌ์ฉ๋๋์ง ์ดํด
yaboong.github.io
'Programming > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
F007 - JVM : Memory Architecture (0) | 2021.05.14 |
---|---|
F006 - Throwable, Exception, Error (0) | 2021.05.11 |
F004 - Reference Type (0) | 2021.05.08 |
F003 - Access Modifier (0) | 2021.05.06 |
F002 - Primitive Type (0) | 2021.05.06 |