JVM์ ์ด๋ป๊ฒ ์คํ ๋๋๊ฐ?JVM์ด .class๋ฅผ ์คํํ๋ ์ ์ฐจ๐ Method AreaJRE Java Runtime EvironmentJVM Memory ํ ๋น ๋ฐฉ์๐ Stack๐ฆ Heapโ ๏ธ ์ฃผ์์ฌํญJava๋ ๋ฌด์กฐ๊ฑด Call by value์ด๋ค?๐ ์ฐธ๊ณ
JVM์ ์ด๋ป๊ฒ ์คํ ๋๋๊ฐ?
Java Code โ .class โ JVM ์์์ ์คํ๋ฉ๋๋ค.
JVM์ด .class๋ฅผ ์คํํ๋ ์ ์ฐจ
- ํด๋น ํด๋์ค๋ฅผ ํ์ฌ ๋๋ ํ ๋ฆฌ์์ ์ฐพ๋๋ค.
- ์ฐพ์ผ๋ฉด ํด๋์ค ๋ด๋ถ์ static ํค์๋๊ฐ ์๋ ๋ฉ์๋๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋ฉ method area โ static zone์ ๋ก๋ฉ ๋ฉ๋๋ค.
- main() ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ์คํ๋๊ฒ ๋ฉ๋๋ค. Stack์ main์ด ๋ค์ด๊ฐ๊ณ , ์๊ฐ ๋น์์ง๋ฉด ํ๋ก๊ทธ๋จ ์ข ๋ฃ!
๐ Method Area
- method์ byte code๊ฐ ์ ์ฅ๋๋ ์์ญ
- static vs none-static ์ผ๋ก ๋๋ ์ง๋๋ค.
JRE Java Runtime Evironment
- JVM
- Java Class Libraries
- Class Loader
JVM Memory ํ ๋น ๋ฐฉ์
๐ Stack
- Primitive ํ์ ๋ณ์๋ค์ด ์ ์ฅ ๋ฉ๋๋ค.
- ์ข์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ
- ๊ฐ Thread๋ ์์ ๋ง์ Stack์ ๊ฐ์ง๋๋ค. ๊ฐ ์ค๋ ๋์์๋ ๋ค๋ฅธ Stack ์์ญ์๋ ์ ๊ทผํ ์ ์์ต๋๋ค.
- ์ง์ญ ๋ณ์๋ค์ scope์ ๋ฐ๋ฅธ
visibility
๋ฅผ ๊ฐ์ง๋๋ค.
๐ฆ Heap
- ๋ณต์กํ ํ์ ์ ํด๋์ค ํ์ , Interface, ArrayType ๋ณ์๋ค์ด ์ ์ฅ
- new ์ฐ์ฐ์๋ฅผ ํตํด ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ ์์ญ
- ๋์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ ๊ฐ์ ํ ๋น, ํด์ ํ๋๋ฐ ๋ง์ ๋น์ฉ์ด ๋ญ๋๋ค. (์์ฃผ ํ๋ฉด Stack ๋ณด๋ค ์์ญ๋ฐฐ์ ๋น์ฉ...?)
- ๋ช๊ฐ์ Thread๊ฐ ์กด์ฌํ๋ ์๊ด์์ด ๋จ ํ๋์ heap์์ญ๋ง ์กด์ฌํฉ๋๋ค.
- Heap ์์ญ์ ์๋ ์ค๋ธ์ ํธ๋ค์ ๊ฐ๋ฆฌํค๋ ๋ ํผ๋ฐ์ค ๋ณ์๊ฐ stack์ ์ฌ๋ผ๊ฐ๊ฒ ๋ฉ๋๋ค.
โ ๏ธ ์ฃผ์์ฌํญ
Wrapper Class - Integer, Double, String...
์ด๋ค์ ๋ชจ๋
Immutable
ํฉ๋๋ค.
Heap์ ์๋ ๊ฐ์ ์ค๋ธ์ ํธ๋ฅผ ๋ ํผ๋ฐ์ค ํ๊ณ ์๋ ๊ฒฝ์ฐ๋ผ๋, ์๋ก์ด ์ฐ์ฐ์ด ์ ์ฉ๋ ์๊ฐ!
์๋ก์ด ์ค๋ธ์ ํธ๊ฐ Heap์ ํ ๋น ๋ฉ๋๋ค.// โ ๋ฌธ์ 1. after a์ ๊ฒฐ๊ณผ ์ถ๋ ฅ๊ฐ์? @Test void printReferenceInteger() { Integer a = 10; System.out.println("before: " + a); changeInteger(a); System.out.println("after: " + a); } private void changeInteger(Integer num) { num += 10; } // โ ๋ฌธ์ 2. after s์ ๊ฒฐ๊ณผ ์ถ๋ ฅ๊ฐ์? @Test void printReferenceString() { String s = "hello"; changeString(s); System.out.println(s); } private static void changeString(String str) { str += " world"; }
์์ ๊ฒฐ๊ณผ๋ ์๋์ ๊ฐ์ต๋๋ค.
๋ฌธ์ 1 : after: 10 ๋ฌธ์ 2 : hello
์๋...!? ๋ณํ์ง ์์๋ค. ๋จธ์ 129 ๐ค
์๋์ ๊ทธ๋ฆผ์ ์ดํด๋ด
์๋ค.

- ์ฒ์์ a ๋ณ์์ 10์ด ํ ๋น๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. (์ด๊ฒ์ ์ฒ์์ 10์ ๊ฐ๋ฆฌํค๊ณ ์์ต๋๋ค.)
- changeInteger()์ ๋งค๊ฐ๋ณ์๋ก ๋์ด๊ฐ ์๊ฐ ๋งค๊ฐ๋ณ์ num์ด a๋ฅผ ๋ณต์ ํ์ฌ ์๋กญ๊ฒ ์์ฑ๋ฉ๋๋ค. (num์ ์ฒ์์๋ a์ ๊ฐ์ด 10์ ์ฐธ์กฐ ํ๊ณ ์์ต๋๋ค.)
- ํ์ง๋ง += 10 ์ด๋ผ๋ ์ฐ์ฐ์ ํ๋ ์๊ฐ, Heap์ ์ฐ์ฐ๋ 20์ด๋ผ๋ ์๋ก์ด ๊ฐ์ด ์ฌ๋ผ๊ฐ๊ฒ ๋ฉ๋๋ค. (num์ ์ด์ 20์ด๋ผ๋ ์๋ก์ด ๊ฐ์ ๊ฐ๋ฆฌํค๊ฒ ๋์ฃ .)
๊ทธ๋ฆฌ๊ณ ๋ง์ง๋ง์ผ๋ก ๋ฉ์๋๋ฅผ ๋ฒ์ด๋๊ฒ ๋๋ฉด, num์ด๋ผ๋ ๊ฐ์ stack์์ ์ฌ๋ผ์ง๊ฒ ๋ฉ๋๋ค.
method๋ผ๋ ์ง์ญ์์ ๋ฒ์ด๋ฌ๊ธฐ ๋๋ฌธ์ด์ฃ .
๋ณด์๋ค์ํผ a๋ผ๋ ๋
์์ ์ฌ์ ํ 10์ ์ฐธ์กฐํ๊ณ ์๊ธฐ ๋๋ฌธ์, ๊ฐ์ด ๋ณํ์ง ์์ ์ฑ๋ก ๊ทธ๋๋ก ์ถ๋ ฅ๋๊ฒ ๋๋ ๊ฒ์ด์ต๋๋ค.
Java๋ ๋ฌด์กฐ๊ฑด Call by value์ด๋ค?
Java์๋ Call by reference๊ฐ ์๋ค๊ณ ํฉ๋๋ค.
ํ์ง๋ง ๋งค๊ฐ๋ณ์๋ก ๋ฐ์์ ๊ฐ์ด ๋ณํ๋ ๊ฒฝ์ฐ๋ ๋ฌด์์ผ๊น์?
class Sample { public int value; Sample(int num) { value = num; } } class Main { public static void main(String[] args) { Sample sam = new Sample(10); run(sam); System.out.println(sam.value); // ๐ ์ด๋ค ๊ฐ์ด ์ถ๋ ฅ ๋ ๊น์? } static void run(Sample sample) { sample.value = 20; } }
๊ฒฐ๊ณผ๊ฐ์ 20์ธ ๊ฐ์ด ์ถ๋ ฅ ๋๊ฒ ๋ฉ๋๋ค.
๊ทธ๋ผ Call by reference์ธ๊ฒ ์๋๊ฐ?! โ ์๋๋๋ค.
- ์ผ๋จ Stack์ sam์ด๋ผ๋ ๊ฐ์ด ์ฌ๋ผ๊ฐ๊ฒ ๋ฉ๋๋ค. (Heap์๋ 10์ด๋ผ๋ ๊ฐ์ ๊ฐ๋ฆฌํค๊ณ ์๊ฒ ์ฃ ?)
- ๊ทธ๋ฆฌ๊ณ run() ๋ฉ์๋๋ก ๋์ด๊ฐ๊ฒ ๋๋ฉด sample์ด๋ผ๋ ๋ณ์๊ฐ stack์ ์๋กญ๊ฒ ์์ฑ๋๊ฒ ๋ฉ๋๋ค. ์ฌ๊ธฐ์ sample์ sam์ด ๊ฐ์ง๋ ์ฃผ์๊ฐ์ ๋ณต์ ํ์ฌ ์์ฑ๋๊ฒ ๋ฉ๋๋ค. ๊ทธ๋์ sample์ ๊ฐ์ ๋ณ๊ฒฝํ๊ฒ ๋๋ฉด, sam์ด ๊ฐ๋ฆฌํค๋ 10์ด๋ผ๋ primitive๊ฐ์ ์ ๊ทผํ์ฌ 20์ผ๋ก ๋ณ๊ฒฝ๋ฉ๋๋ค.
์ด๋ ๊ฒ ์ฃผ์๋ผ๋ ๊ฐ์ ๋ณต์ ํ์๊ธฐ ๋๋ฌธ์, ๋ณ๊ฒฝ์ด ๋๋ ๊ฒ์
๋๋ค.
์ฆ ์ด๊ฑด Call by value๋ผ๊ณ ๋ณผ ์ ์์ต๋๋ค.
๊ทธ๋์ ๊ฒฐ๋ก ์? 'Java์ Call by reference๋ ์๋ค.' ์
๋๋ค.