CPU์ ๊ตฌ์กฐ
๐ก Control Unit : ๋งค๋์
ALU : ๊ณ์ฐ
๋ ์ง์คํฐ : ๊ธฐ์ต๋ ฅ
๋ ์ง์คํฐ
- ํ๋ก๊ทธ๋จ ์นด์ดํฐ โ ํ์ฌ ์คํ ์ค์ธ ์์ค์ฝ๋ ๋ผ์ธ
- ๋ช
๋ น์ด ๋ ์ง์คํฐ โ ํ์ฌ ์คํ ์ค์ธ ๋ช
๋ น์ด
- ๋ฉ๋ชจ๋ฆฌ ์ฃผ์ ๋ ์ง์คํฐ โ ํ๊ฒ(๋ชฉํ)
- ๋ฉ๋ชจ๋ฆฌ ๋ฐ์ดํฐ ๋ ์ง์คํฐ โ ํ๊ฒ์์ ๊ฐ์ ธ์จ ๋ฐ์ดํฐ or ํ๊ฒ์ ๋ฃ์ ๋ฐ์ดํฐ
- ์ดํ๋ฎฌ๋ ์ดํฐ โ ๊ณ์ฐ ๊ฐ. cpu์์ ๊ณ์ฐ ๊ณผ์ ์ค ๋ฐ์ํ๋ ๋ฐ์ดํฐ ์ ์ฅ.
๋ ์ง์คํฐ ์ค๋ช
- CPU์๋ ๋ ์ง์คํฐ๊ฐ ์๊ณ , ๋ ์ง์คํฐ ์์ ์๋
๋ฉ๋ชจ๋ฆฌ ์ฃผ์ ๋ ์ง์คํฐ(๋ชฉํ) ๊ฐ 104 ๋ฒ์ง๋ผ ํ์.
- RAM์ผ๋ก ๊ฐ์ 104๋ฒ์ง ์์น์ ์๋ ๋ฐ์ดํฐ ๊ฐ์ ๊ฐ์ ธ์
โ ๋ฉ๋ชจ๋ฆฌ ๋ฐ์ดํฐ ๋ ์ง์คํฐ(๊ฒฐ๊ณผ) ๋ก ๊ฐ์ ธ์จ๋ค. ์ด๋ฅผ 44๋ผ ํ์.
์ ๋ณด์ ๋จ์
์ 64bit ์ปดํจํฐ๋ฅผ ์จ์ผ ํ๋๊ฐ ?
- 32๋นํธ OS ์ 64 ๋นํธ OS
32๋นํธ cpu
์ ๋ง์ถฐ์ง os
64๋นํธ cpu
์ ๋ง์ถฐ์ง os
- cpu์์ ๋ ์ง์คํฐ๊ฐ ๊ธฐ๋ณธ ์ ์ฅ ๋จ์์ด๋ค.
- 16๋นํธ cpu 1์๋ โ 16bit
- 32๋นํธ cpu 1์๋โ 32bit
- 64๋นํธ cpu 1์๋โ 64bit
๐ค 32๋นํธ os์์๋ RAM์ 4GB ์ด์ ์ธ ์ ์๋ค.
- 32bit os ์ปดํจํฐ : cpu์์ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ๋ฅผ ๋ด๋ ๊ทธ๋ฆ์ ํฌ๊ธฐ๊ฐ 32bit
โ ์ด๋ฅผ 1์๋ ๋ผ๊ณ ํ๋ค.
โ ์ฆ, 2^32 = ์ฝ 42์ต. 0~42์ต ์ ๋์ ๋ฒ์๋ฅผ ์ ์ฅํ ์ ์๋ค.
- ๊ทธ๋ฌ๋ ๋ง์ฝ RAM 8GB ๋ผ๋ฉด,
๋ฐฉ(1byte) ๊ฐ ์ฝ 85์ต ๊ฐ
๊ฐ ์กด์ฌํ๋คโฆ (์ฉ๋ ์ ํ์ ์๋ ์ฐธ๊ณ )
(RAM์ ์ํคํ
์ฒ ์ ํ์ค ๋ฐฉ ํ๋ ํฌ๊ธฐ๊ฐ 1byte๋ก ์ค์ ๋์ด ์์)
- ์ฆ, 32bit os ์ปดํจํฐ๊ฐ ๋ด์ ์ ์๋ ๋ฒ์๋ฅผ 8GB RAM์ด ์ด๊ณผํด๋ฒ๋ฆฐ๋คโฆ
CPU - Register - RAM
๐ก cpu ๋ ์ง์ RAM ์ ๊ฐ์ง ์๊ณ ,
๋ ์ง์คํฐ๋ฅผ ํตํด ์ ๊ทผํ๋ค. (์ฃผ์ ๋ ์ง์คํฐ, ๋ฐ์ดํฐ ์ฃผ์ ๋ ์ง์คํฐ)
์๋ฅผ ๋ค์ด, ์ฃผ์ ๋ ์ง์คํฐ์ 30์ต์ด๋ผ๋ ์ซ์๊ฐ ๋ค์ด์๋ค๋ฉด,
RAM์ 30์ต๋ฒ ์งธ ๋ฐฉ์ ์ ๊ทผํด์, ๊ฑฐ๊ธฐ์ ์ ํ ๋ฐ์ดํฐ โ4โ๋ฅผ ๋ฐ์ดํฐ ์ฃผ์ ๋ ์ง์คํฐ์ ์ ์ฅํ๋ ๋ฐฉ์์ด๋ค.
์ฉ๋ ์ ํ
- 8bit = 1byte
1024byte = 1KB
1024KB = 1MB
1024MB = 1GB
C์ธ์ด & CS
์ปดํจํฐ ๊ตฌ์ฑ
์ด์์ฒด์ ์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ
- ์ด์์ฒด์ ๊ฐ
๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ด๋ฆฌ
ํ๋ค.
c ํ๋ก๊ทธ๋จ โ ์ด์์ฒด์ ์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์์ฒญ
- ๋์์ 2๊ฐ์ง ํ๋ก๊ทธ๋จ์ด ์คํ๋ ๋, ์๋ก ๊ฐ์ ๋ถ๋ถ์ ์ฌ์ฉํด์ ๋ฉ๋ชจ๋ฆฌ ์์ญ ์นจ๋ฒ์ด ์ผ์ด๋ ์ ์์๊น?
โ ์๋ค!
์ด์์ฒด์ ์ ๋ฉ๋ชจ๋ฆฌ ๊ฐ์ํ
- ํ๋ก์ธ์ค๋ค์
๋ฌผ๋ฆฌ RAM
์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ ๋ ์๋๋ค!
- ํ๋ก์ธ์ค๋ค์ ํ๋์ ๋ฌผ๋ฆฌ RAM์ ๊ณต์ ํ์ง๋ง,
ํ๋ก์ธ์ค๋ง๋ค ๊ฐ์์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋น๋ฐ๋๋ค.
์ฆ, ํ๋ก์ธ์ค์์ ์ฌ์ฉํ๋ RAM์ ๋
ผ๋ฆฌ RAM
์ด๋ผ๊ณ ํ ์ ์๋ค.
(๋ฌผ๋ฆฌ์ ์ผ๋ก๋ ํ๋์ง๋ง, ๋ง์น ๋
๋ฆฝ์ ์ผ๋ก ์ฌ์ฉํด์ ๊ฐ์
์ด๋ผ๋ ์๋ฉ ์ฌ์ฉ)
- ์ด์์ฒด์ ๊ฐ ํ๋ก์ธ์ค๊ฐ ์์์ด๋๋ก ๋ณด์ฅํ๋ค.
- ํ๋ก์ธ์ค๋ค์ ์๋ถํ ๋ฐฉ์(๋น ๋ฅธ ์๋๋ก ๋ฒ๊ฐ์ ๊ฐ๋ฉฐ ์คํ)์ผ๋ก ๋์
- ๊ฐ ํ๋ก์ธ์ค๊ฐ ์์์ด๋๋ก, ๋
๋ฆฝ์ ์ธ ๊ณต๊ฐ์์ ์คํ๊ณผ ํ์ ์ฌ์ฉํ๋ค.
์๋์ฐ์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ
- ์ด์์ฒด์ ์ ๋ฉ๋ชจ๋ฆฌ ๊ฐ์ํ๋ ํท๊ฐ๋ฆฌ์ง ๋ง์.
- ์๋์ฐ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ ์๋์ฐ์๋ง ์กด์ฌ. (๋ฆฌ๋
์ค๋ ์ค์์ด๋ผ๊ณ ํจ)
- RAM์ ๋ฐ์ดํฐ๊ฐ ๋ถ์กฑํ ๋,
๊ฐ์๋ฉ๋ชจ๋ฆฌ
์ผ๋ถ๋ถ์ ๋จ๊ฒจ๋๋๋ค.
โ ํ๋๋์คํฌ์ ์ผ๋ถ๋ถ์ RAM์ผ๋ก ์ฌ์ฉํ๋ ์๋ฆฌ์ด๋ค.
์๋ฅผ ๋ค์ด, ํ๋ก์ธ์ค A ์ ํ๋ก์ธ์ค B๊ฐ ๋์์ ์คํ๋๊ณ ์๋ค๋ฉด,
โ ๋ ๋ค 4GB ์ด์
์ฉ ์กํ๋ค.
โ ํ๋ก๊ทธ๋จ์ ์๋๋ฅผ ๋ฆ์ถ๋ ๋์ , ์ฉ๋์ ๋ง์ด ์ค๋ค.
๋ณ์ํ์
-
character โ 1byte ์ ์. 256. ์์๋ถํฐ ์ธ์ผํ๋ฏ๋ก,
โ -128 ~ 127 (0ํฌํจ)
-
short โ 2byte ์ ์. 32000๊น์ง ๊ฐ๋ฅ.
-
int โ -21์ต ~ +21์ต๊น์ง ์ ์ฅ ๊ฐ๋ฅ.
-
unsigned char i = 200;
โ unsigned ๋ ์์๋ฅผ ๋ฒ๋ฆฐ๋ค!
printf(โ%uโ, i); โ unsigned๋ %u ๋ฅผ ์ฌ์ฉ.
-
22์ต์ ์ ์ฅํ๋ ค๋ฉด ?
unsigned int s = 2200000000; // ์์๋ง ํฌํจํ๋ฏ๋ก 42์ต๊น์ง ๊ฐ๋ฅ.
โ ์ด๊ฒ ์ญ์ printf(โ%uโ, s);
โ %d ๋ -21์ต ~ +21์ต ๊น์ง๋ง care ๊ฐ๋ฅ.
os์ ํ๋ก๊ทธ๋จ ๊ตฌํ ์ต์ ํ, ํ๋ก๊ทธ๋๋ฐ ์ธ์ด
- ํ๋๋์คํฌ๋ ๊ณต๊ฐ์ด ์ถฉ๋ถํ๋ค!
- RAM์ ๊ณต๊ฐ์ด ๋ ๋ถ์กฑํ๋ค.
- ์ฆ, ํญ์ RAM์ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ๋ ๋ฐฉํฅ์ผ๋ก ํผ์ณ์ง๋ค.
๐ก ๋ฉ๋ชจ๋ฆฌ๋ ๋ ๋ถ์กฑํ๋ค !!!
๋ชจ๋ ์ต์ ํ, ๋ชจ๋ ๊ธฐ๊ต โ ๋ฉ๋ชจ๋ฆฌ ์์ฃผ๋ก ๋ฐ์ !
ํจ์๋ ์ ์คํ
์ ๋ชจ์๋์๊น์ ?
- ๋ฉ๋ชจ๋ฆฌ๋ผ๋ ๋ํ์ง์ ์ด๊ณณ์ ๊ณณ ๊ทธ๋ ค๋์ผ๋ฉด, ๊ณต๊ฐ์ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
โ ์ฆ, ๋น๊ณต๊ฐ ์์ด ํ์ฉํ๊ธฐ ์ํด์๋ค.
- ์ฌ์ฉ์๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ผ๋ง๋ ์ฌ์ฉํ ์ง ์์ธกํ ์ ์๊ธฐ ๋๋ฌธ์, ์ต๋ํ ์คํ์ผ๋ก ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
- ๊ทธ๋ฐ๋ฐ, ์คํ์์ โ์ฌ์ ๊ณต๊ฐโ ์ด ํ์ํ ๊น ?
๋ฉ๋ชจ๋ฆฌ์ ๋ถ๋ฐฐ
- ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฐฉ์ด์ ์ผ๋ก ๋ถ๋ฐฐํด์ผ, ๋์ค์ โํโ ์ผ๋ก ๋์ ํ ๋น ํ ๋ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ๋ค.
- stack ์ง์ญ์๋ ํจ์๊ฐ ์์ธ๋ค. ๋, ์ง์ญ๋ณ์๊ฐ ์์ธ๋ค. (heap ์์ญ์ ๊ฐ์ฒด๊ฐ ์์.)
(๋งค๊ฐ๋ณ์๋ ์ง์ญ๋ณ์๋ค)
- code ์์ญ์๋ int , return ๋ฑ ์ฝ๋ ์ ๋ณด๋ค์ด ์์ธ๋ค.
๋ฐ๋์ ์์์ผ ํ ๊ฒ(์ ๋ฆฌ)
- ์๋์ ๋ถํฐ ์ฐจ๊ณก์ฐจ๊ณก ๋ถ์ฌ์ ์์ด๋ ์ด์
โ ์ต๋ํ ๋ฐฉ์ด์ ์ผ๋ก ์จ์ผ ํ๋ค. ์์ผ๋ก ์ผ๋ง๋ ์ธ ์ง ๋ชจ๋ฅด๋๊น.
โ ์ฆ, ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๋ผ๊ธฐ ์ํด์๋ค !!
- ๋งค๊ฐ๋ณ์, ์ผ๋ฐ์ง์ญ๋ณ์ ๋ชจ๋ ์ง์ญ๋ณ์์ด๋ค.
โ ์คํ์ ์์ธ๋ค.
Java
intllij setting
Java ์ ํน์ง
- ํด๋์ค ๋ง๋ค ๋, ์ฌ์ ์ ์์ฑ, ๋ฉ์๋ ๋ฑ ๊ตฌ์ฑ์ ์๋ฃํด์ผ ํ๋ค.
- Car car ๋ JVM ์ฝ๋ ์์ญ์ ์ ์ฅ.
- new Car(); ์ ๊ฐ์ด new๋ฅผ ํตํด heap ์์ญ์ผ๋ก ๊ฐ์ ธ์ค๋๋ฐ,
๊ฐ์ ธ์ฌ ๋ ์์ฑ์ด๋ ๋ฉ์๋๊ฐ ์๋ค๋ฉด, ๋น ๊ป๋ฐ๊ธฐ๋ง ๊ฐ์ ธ์ค๊ฒ ๋จ.
ํด๋์ค์ ๊ฐ์ฒด!! (์ค์ํจ)
Class Car { }
ํด๋์ค(์ค๊ณ๋) : ์๋ณธ ํด๋ โ JVM/์ฝ๋์์ญ/ํด๋์ค/Car ์์ฑ.
new Car();
๊ฐ์ฒด(์ ํ) : ๋ณต์ฌ๋ณธ ํด๋ โ JVM/์ฝ๋์์ญ/ํด๋์ค/Car ๋ณต์ฌํด์
โ JVM/Heap/ํด๋์ค/Car/Car@1
๊ฐ์ฒด๋ ํด๋, ๋ณ์๋ ํ
์คํธํ์ผ(R/W), ํจ์(๋ฉ์๋)๋ ์คํ(exe)ํ์ผ์ด๋ผ๊ณ ๋ณผ ์ ์๋ค.
Car aCar = new Car();
// 2๊ฐ์ง โ ๊ฐ์ฒด
, ๊ฐ์ฒด๋ฆฌ๋ชจ์ฝ
- new Car(); ํ๋ ์๊ฐ, heap ์
**๊ฐ์ฒด**
๊ฐ ๋ง๋ค์ด์ง๊ณ , ๊ฐ์ฒด ์์๋ ์๊ธฐ ์์ (this)์ ์กฐ์ข
ํ ์ ์๋ ๊ฐ์ฒด ๋ฆฌ๋ชจ์ฝ
์ด ๋ง๋ค์ด์ง๋ค.
- ์๋์ฐจ ๋ณ์ aCar ์ Stack ์์ญ์ ๋ง๋ค์ด์ง๊ณ , heap์ ๋ง๋ค์ด์ง ๊ฐ์ฒด
๋ณต์ฌ๋ณธ์ด ์ ์ฅ
๋๋ค. (์ด ์์๋ ๊ฐ์ฒด ๋ฆฌ๋ชจ์ฝ
์ด ์๋ค.)
โ ์ฆ, new ๋ฅผ ํ ๋ฒ ํด์ฃผ๋ฉด ๊ฐ์ฒด ๋ฆฌ๋ชจ์ฝ์ด 2๊ฐ ์์ฑ๋๋ค.
Car aCar1 = new Car();
Car aCar2 = aCar1;
// aCar1 ์ 1๋ฒ Car๋ฅผ ์กฐ์ข
ํ ์ ์๋ ๋ฆฌ๋ชจ์ฝ์ด๋ค. (๋ณ์๊ฐ ์๋)
- aCar1 ์ ๊ฐ์ฒด ๋ ํผ๋ฐ์ค ๋ณ์, ์ฐธ์กฐ ๋ณ์๋ผ๊ณ ํ๋ค. (์ฝ๊ฒ ํํํด์, ๊ฐ์ฒด ๋ฆฌ๋ชจ์ฝ)
Car aCar1 = new Car();
Car aCar2 = new Car();
aCar2 = aCar1; // ๋ ์ด์ aCar2 ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ ๋ ํผ๋ฐ์ค ๋ณ์๊ฐ ์๋คโฆ
- ์ด๋ด ๋,
Garbage Collector
๊ฐ heap ์์ญ
์ ๋์๋ค๋๋ฉด์ ์ฃผ์ธ ์์ด๋ฒ๋ฆฐ ๊ฐ์ฒด๋ฅผ ์๊ฑฐํด๊ฐ๋ค.
- ํจ์๊ฐ ์์๋๋ฉด ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ง๋ค์ด์ง๊ณ , ํจ์๊ฐ ๋๋๋ฉด ์ฌ๋ผ์ง๊ธฐ ๋๋ฌธ์
โ aCar1 ์ญ์ ํจ์๊ฐ ์ข
๋ฃ๋๋ฉด Garbage Collector ๊ฐ ์๊ฑฐํด๊ฐ๋ค!
์ฐธ๊ณ ๋์์ ์ฌ๊ธฐ
public static void main(String[] args) {
int a;
Car car1 = new Car();
}
๋ฆฌ๋ชจ์ฝ(๋ ํผ๋ฐ์ค ๋ณ์)์ด ๊ฐ์ฒด๋ฅผ ๋ฐ๋ผ๋ณธ๋ค
- ๋ ํผ๋ฐ์ค ๋ณ์๋ ์ ํํ ๋งํ๋ฉด, ๊ฐ์ฒด์ โ์ฃผ์โ๋ฅผ ์ ์ฅํ๋ ๊ฒ.
- ์ด โ์ฃผ์โ๊ฐ ๊ณง ๊ฐ์ฒด ๋ฆฌ๋ชจ์ฝ, ๊ฐ์ฒด๋ฅผ ์กฐ์ข
ํ ์ ์๋ค.
์๋ฐ์๋ 2๊ฐ์ง ๋ณ์ ํ์
์ด ์๋ค
- ์ผ๋ฐ ๋ฐ์ดํฐ ํ์
- byte, short, int, long
- char
- boolean
- float, double
- ๋ ํผ๋ฐ์ค ํ์
- ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ๋ ํผ๋ฐ์ค(๋ฆฌ๋ชจ์ฝ)
โ ์ด ์์๋ ์ฃผ์๊ฐ
์ด ๋ค์ด ์๋ค.