Servlet๊ณผ Spring์ ์ฐจ์ด
์๋ธ๋ฆฟ์ http์ ์์ฒญ์ด๋ ์๋ต์ ๋ฐ์ ์ฒ๋ฆฌํ๋ ๊ธฐ๋ณธ ํด๋์ค์
๋๋ค.
ํ๋์ ์์ฒญ์ด์์๋ ์๋ต์ ์ฃผ๋ ๊ตฌ์กฐ๋ก ์ค๊ณ๋ ๊ตฌ์กฐ์
๋๋ค. ํ์ง๋ง ์ด๋ ์์ฒญ๋ง๋ค ์๋ธ๋ฆฟ์ ์ ์ํด์ผํ๋ ๋จ์ ์ด ์์๊ณ ๊ทธ๋์ ๋์จ๊ฐ๋
์ด ๋์คํจ์ฒ ์๋ธ๋ฆฟ์
๋๋ค. spring์โฆ
์ ๊ทํ์ ์ฅยท๋จ์
์ ๊ทํ๋?
DB์ ์ค๋ณต์ ์ ๊ฑฐํ๊ณ ๋ฐ์ดํฐ๋ฅผ ๊ตฌ์กฐํํ๋ ๊ณผ์ ์
๋๋ค. ์ด๋ฅผ ํตํด ์ด์ํ์์ ์ค์ผ์ ์์ต๋๋ค.
ํ์ง๋ง, ๊ณผ๋ํ ์ ๊ทํ๋ก ์ธํด ๋ณต์กํ ๊ตฌ์กฐ์ ์ฑ๋ฅ ์ ํ๋ฅผ ์ผ์ผํฌ ์ ์์ต๋๋ค.
๋ก๋๋ฒจ๋ฐ์ฑ L7๊ณผ L4์ ๋ํด ์ค๋ช ํด๋ณด์์ค
L4 ๋ก๋๋ฐธ๋ฐ์ฑ
์ IP ์ฃผ์์ ํฌํธ ๋ฒํธ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํธ๋ํฝ์ ๋ถ์ฐํ๋ ๋ฐฉ์์
๋๋ค. L4 ๋ก๋๋ฐธ๋ฐ์๋ OSI ๋ชจ๋ธ์ 4๊ณ์ธต(์ ์ก ๊ณ์ธต)์์ ๋์ํ๋ฉฐ, TCP ๋ฐ UDP์ ๊ฐ์ ์ ์ก ๊ณ์ธต ํ๋กํ ์ฝ์ ์ฌ์ฉํ์ฌ ํธ๋ํฝ์ ๋ถ์ฐํฉ๋๋ค.
L7 ๋ก๋๋ฐธ๋ฐ์
๋ HTTP ๋ฐ HTTPS์ ๊ฐ์ ์์ฉ ๊ณ์ธต ํ๋กํ ์ฝ์ ์ฌ์ฉํ์ฌ ํธ๋ํฝ์ ๋ถ์ฐํฉ๋๋ค. L7 ๋ก๋๋ฐธ๋ฐ์๋ ํธ๋ํฝ์ ๋ด์ฉ์ ๋ฐ๋ผ ํธ๋ํฝ์ ๋ถ์ฐํ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค. ์๋ฅผ ๋ค์ด, L7 ๋ก๋๋ฐธ๋ฐ์๋ URL, ์ฟ ํค, ํค๋ ๋ฑ์ ์ ๋ณด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํธ๋ํฝ์ ๋ถ์ฐํ ์ ์์ต๋๋ค.
๋๋ค์ ๊ทผ, ์์ฐจ์ ๊ทผ์ ์ฅยท๋จ์
๋๋ค์ ๊ทผ(Random Access)๊ณผ ์์ฐจ์ ๊ทผ(Sequential Access)์ ์ปดํจํฐ์์ ๋ฐ์ดํฐ์ ์ ๊ทผํ๋ ๋ฐฉ์์ ๋๋ค.
๋๋ค์ ๊ทผ
์ ์ฅ์ ์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด ๋งค์ฐ ์งง๋ค๋ ๊ฒ์
๋๋ค. ๋ฐ์ดํฐ๋ฅผ ์ฝ์
ํ๊ฑฐ๋ ์์ ํ๋ ์์
๋ ๋งค์ฐ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๊ฐ ๋งค์ฐ ํฐ ๊ฒฝ์ฐ์๋ ์ฒ๋ฆฌ ์๊ฐ์ด ๊ธธ์ด์ง ์ ์์ต๋๋ค. ๋ํ ๋ฐ์ดํฐ์ ๊ตฌ์กฐ๋ ์์์ผํฉ๋๋ค.
์์ฐจ์ ๊ทผ
์ ๋ฐ์ดํฐ์ ์ฒ์๋ถํฐ ๋๊น์ง ์์๋๋ก ์ ๊ทผํ๋ ๋ฐฉ์์
๋๋ค. ๋ฐ์ดํฐ์ ๊ตฌ์กฐ์ ๋ํ ์ ๋ณด๋ฅผ ๋ฏธ๋ฆฌ ์์ง ๋ชปํด๋ ์ฒ๋ฆฌํ ์ ์๋ค๋ ์ฅ์ ์ด ์์ต๋๋ค. ํ์ง๋ง ๊ฒ์, ์์ ์ ์์ด ๋งค์ฐ ๋๋ฆฝ๋๋ค.
ArrayList()์ Vector์ ์ฐจ์ด
ArrayList
์ vector
์ ์ฐจ์ด๋ thread safe ์ฌ๋ถ์
๋๋ค. vetor๋ ๋ด๋ถ์ ์ผ๋ก synchronized๋ฅผ ํตํด ๋ฐ์ดํฐ์ ์ผ๊ด์ฑ์ ๋ณด์ฅํฉ๋๋ค. ํ์ง๋ง ๊ทธ์๋ฐ๋ผ ์๋๊ฐ ๋๋ ค์ง๋๋ค. ๋ํ ๋์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ํ ๋นํ ๋๋ง๋ค ArrayList
๋ 50% ์ฆ๊ฐํ๋ ๋ฐ๋ฉด vector
๋ 100% ์ฉ๋์ ์ฆ๊ฐ ์ํจ๋ค.
์์ง๋์ ๊ฒฐํฉ๋์ ๋ํ ์ค๋ช
์์ง๋
๋ ๋์์๋ก ๊ฒฐํฉ๋
๋ ๋ฎ์ ์๋ก ์ข๋ค
์์ง๋
๋ ์ผ๋ง๋ ๋ชจ๋ ์์ ์ฝ๋๋ค์ด ๋จ์ผํ ๋ชฉ์ ์ผ๋ก ์ํ๋๋์ง์ ์ฌ๋ถ
์์ง๋์ ์ข์์
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public int subtract(int a, int b) {
return a - b;
}
public int multiply(int a, int b) {
return a * b;
}
public int divide(int a, int b) {
return a / b;
}
}
๋ฉ์๋๊ฐ ๋ช ํํ๊ฒ ๋ถ๋ฆฌ๋์ด์๊ณ ๋ ๋ฆฝ์ ์ผ๋ก ์๋ํจ.
์์ง๋์ ๋์์
ํ๋์ class์์ get, set์ด ์๊ณ ๋ถ๋ถ๋ช
ํ ๋ฉ์๋์ ๋ณต์กํ ๋ฆฌํด๊ฐ์ ๊ฐ์ง๋ ๊ตฌ์กฐ๋ฅผ ์๋ก ๋ค์ ์๋ค.
๊ฒฐํฉ๋
๋ ๋ชจ๋๊ฐ์ ์์กด์ฑ์ ๋ํ๋ธ ๊ฒ DI ์ฃผ์
๋ฐ์ ํ๋๊ฒ ๊ฒฐํฉ๋๊ฐ ๋ฎ์ ์ค๊ณ
SOAP์ REST API์ ์ฐจ์ด
๋๋ค ์น์๋น์ค ๋ฐฉ์์ด์ง๋ง, SOAP
์ XML ๊ธฐ๋ฐ์ ๋ฉ์์ง ๊ตํ์ ์ํ ํ๋กํ ์ฝ์
๋๋ค.
SOAP
์ WSDL (Web Services Description Language)
์ ์ฌ์ฉํ์ฌ ์๋น์ค๋ฅผ ์ค๋ช
ํ๊ณ , ์๋น์ค์ ๋ฉ์๋๋ฅผ XML๋ก ์ ์ํ๋ฉฐ, SOAP
๋ฉ์์ง๋ฅผ ๋ณด๋ด๊ณ ๋ฐ์ ์ ์์ต๋๋ค. SOAP
๋ ๋ณด์๊ณผ ํธ๋์ญ์
๊ด๋ฆฌ๋ฅผ ์ง์ํ๋ฉฐ, ๋ณต์กํ๊ณ ๋ง์ ๊ธฐ๋ฅ์ ์ ๊ณตํ์ง๋ง, ์ฒ๋ฆฌ ์๋๊ฐ ๋๋ฆฌ๊ณ , ๊ตฌํ์ด ๋ณต์กํฉ๋๋ค.
REST
๋ HTTP ํ๋กํ ์ฝ์ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํ๋๋ API์
๋๋ค. REST
๋ URL์ ์ฌ์ฉํ์ฌ ๋ฆฌ์์ค๋ฅผ ์ ์ํ๋ฉฐ, HTTP ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ฆฌ์์ค์ ๋ํ ์ก์
์ ์ ์ํฉ๋๋ค.
REST
๋ ๊ฒฝ๋ํ๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ๊ฐ๋จํ๊ณ ๋น ๋ฅธ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
REST
๋ ๋ณด์๊ณผ ํธ๋์ญ์
๊ด๋ฆฌ ๊ธฐ๋ฅ์ด SOAP
๋ณด๋ค ์ ํ์ ์ด์ง๋ง, ๊ตฌํ์ด ์ฝ๊ณ ์ฑ๋ฅ์ด ์ฐ์ํฉ๋๋ค.SOAP
๋ ๋ณด์์ด๋ ๋ณต์กํ ํธ๋์ญ์
์ฒ๋ฆฌ๊ฐ ํ์ํ ๊ฒฝ์ฐ์ ์ ํฉํ๋ฉฐ, REST
๋ ๊ฐ๋จํ๊ณ ๋น ๋ฅธ ์ฒ๋ฆฌ๊ฐ ํ์ํ ๊ฒฝ์ฐ์ ์ ํฉํฉ๋๋ค.
JDK JRE JVM ๊ฐ๋จํ๊ฒ ์ค๋ช
JDK
๋ ์๋ฐ ๊ฐ๋ฐ ๋๊ตฌ๋ฅผ ์ ๊ณตํ๋ ํจํค์ง์ด๋ฉฐ,
JRE
๋ ์๋ฐ ์ ํ๋ฆฌ์ผ์ด์
์ ์คํํ ์ ์๋ ๋ฐํ์ ํ๊ฒฝ์ด๋ฉฐ,
JVM
์ ์๋ฐ ์ ํ๋ฆฌ์ผ์ด์
์ ์คํํ๊ธฐ ์ํ ๊ฐ์ ๋จธ์ ์
๋๋ค
Spring๊ณผ Springboot ์ฐจ์ด
Spring
- ๋ค์ํ ๋ชจ๋๊ณผ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ง์ํ์ฌ ์ ์ฐ์ฑ์ด ๋๋ค.
- DI, AOP, MVC ๋ฑ์ ๊ธฐ๋ฅ์ ์ ๊ณตํ์ฌ ๊ฐ๋ฐ ์์ฐ์ฑ์ ๋์ผ ์ ์๋ค.
- ๋ค์ํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฐ๋์ด ๊ฐ๋ฅํ๋ฉฐ, ORM ํ๋ ์์ํฌ์ธ Hibernate์ ์ฐ๋ํ์ฌ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
๋จ์ :
- ์ค์ ์ด ๋ณต์กํ๊ณ , ๊ธฐ๋ฅ์ด ๋ณต์กํ ๋งํผ ํ์ต์ด ์ด๋ ค์ธ ์ ์๋ค.
- ๋ฐฐํฌ ๋ฐ ์ด์์ ์์ด์๋ ์๋ฒ์ ํ๊ฒฝ์ ๋ง๊ฒ ์ค์ ํ๋๋ฐ ์๊ฐ์ด ๋ง์ด ์์๋๋ค.
- ์ด๊ธฐ ์ธํ ๊ณผ ํ๋ก์ ํธ ์์ฑ์ด ๋ฒ๊ฑฐ๋กญ๋ค.
Spring Boot
- Spring์ ์ค์ ์ ์๋ํํ์ฌ ๊ฐ๋ฐ์๊ฐ ์์ฝ๊ฒ ๊ฐ๋ฐํ ์ ์๋๋ก ๋์์ค๋ค.
- ๋ด์ฅ๋ ํฐ์บฃ, Jetty ๋ฑ์ WAS๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๋ฐ์ ์งํํ ์ ์์ด, ๋ฐฐํฌ์ ์คํ์ด ๊ฐํธํ๋ค.
- ๊ฐ๋จํ ํ๋ก์ ํธ๋ ๋ง์ดํฌ๋ก์๋น์ค ๋ฑ์ ๋น ๋ฅธ ํ๋กํ ํ์ดํ ๋ฐ ๊ฐ๋ฐ์ ์ ํฉํ๋ค.
๋จ์
- ํ๋ก์ ํธ์ ๊ท๋ชจ๊ฐ ์ปค์ง์๋ก ์ค์ ์ ์ถ๊ฐํ๊ฑฐ๋ ์์ ํ ํ์๊ฐ ์๋ค.
- Spring์ ๊ธฐ๋ฅ๊ณผ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ชจ๋ ๋ด์ฅํ๊ณ ์์ด, ๋ถํ์ํ ๋ถ๋ถ๋ ํจ๊ป ๋ด์ฅ๋์ด ๋ฌด๊ฑฐ์ธ ์ ์๋ค.
- ๊ธฐ์กด์ Spring Framework์ ๋นํด ๊ณ ๊ธ ์ค์ ์ด๋ ์ปค์คํฐ๋ง์ด์ง์ด ์ด๋ ค์ธ ์ ์๋ค.
Call by value ์ Call by reference
์ด ๋์ ํจ์ ํธ์ถ ๋ฐฉ์์ด ์ด๋ค ๋ฐฉ์์ผ๋ก ๋งค๊ฐ๋ณ์๋ฅผ ์ ๋ฌํ๋ ์ง์ ๋ฐ๋ผ ๋ค๋ฆ
๋๋ค.
Call by value
๋ ๊ฐ์ ์ํ ํธ์ถ์ด๋ผ๊ณ ๋ ํ๋ฉฐ, ํจ์๊ฐ ํธ์ถ๋ ๋ ์ธ์๋ก ์ ๋ฌ๋๋ ๋ณ์์ ๊ฐ์ ๋ณต์ฌํ์ฌ ์ ๋ฌํฉ๋๋ค. ๋ฐ๋ผ์ ํจ์ ๋ด๋ถ์์ ๋งค๊ฐ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝํด๋, ํธ์ถํ ์ธก์ ๋ณ์ ๊ฐ์๋ ์ํฅ์ ๋ฏธ์น์ง ์์ต๋๋ค. ์๋ฐ๊ฐ ๋ํ์ ์ธ ์์
๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
public static void swapByValue(int x, int y) {
int temp = x;
x = y;
y = temp;
}
public static void main(String[] args) {
int a = 10;
int b = 20;
swapByValue(a, b);
System.out.println("a=" + a + ", b=" + b);
}
call by reference
๋ ์ฐธ์กฐ์ ์ํ ํธ์ถ์ด๋ผ๊ณ ๋ ํ๋ฉฐ, ํจ์๊ฐ ํธ์ถ๋ ๋ ์ธ์๋ก ์ ๋ฌ๋๋ ๋ณ์์ ์ฐธ์กฐ๋ฅผ ์ ๋ฌํฉ๋๋ค. ๋ฐ๋ผ์ ํจ์ ๋ด๋ถ์์ ๋งค๊ฐ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝํ๋ฉด, ํธ์ถํ ์ธก์ ๋ณ์ ๊ฐ๋ ํจ๊ป ๋ณ๊ฒฝ๋ฉ๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
public static void swapByReference(int[] arr) {
int temp = arr[0];
arr[0] = arr[1];
arr[1] = temp;
}
public static void main(String[] args) {
int[] arr = {10, 20};
swapByReference(arr);
System.out.println("arr[0]=" + arr[0] + ", arr[1]=" + arr[1]);
}
web server์ was์ ์ฐจ์ด
Web Server
: ์ ์ ์ธ ์ฝํ
์ธ ์ฒ๋ฆฌ์ ์ต์ ํ๋์ด ์์ผ๋ฉฐ, ๋์ฒด๋ก WAS๋ณด๋ค ๋น ๋ฆ
๋๋ค.
WAS
: ์ ํ๋ฆฌ์ผ์ด์
๋ก์ง์ ์ํํ๋ฏ๋ก ์ผ๋ฐ์ ์ผ๋ก ์น ์๋ฒ๋ณด๋ค ๋๋ฆฝ๋๋ค.
Web Server
๋ ์ฃผ๋ก ์ ์ ์ธ ์ฝํ
์ธ ์ฒ๋ฆฌ์ ์ค์ ์ ๋๋ฉฐ, WAS
๋ ์ ํ๋ฆฌ์ผ์ด์
๋ก์ง์ ์ํํ๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๋ ๋ฑ์ ์์
์ ์ฒ๋ฆฌํฉ๋๋ค. ์ด ๋ ๊ฐ์ง ์๋ฒ๋ฅผ ์ ์ ํ๊ฒ ์กฐํฉํ์ฌ ํ๋์ ์น ์ดํ๋ฆฌ์ผ์ด์
์ ๊ตฌ์ฑํ ์ ์์ต๋๋ค
API vs ๋ผ์ด๋ธ๋ฌ๋ฆฌ vs Framework ์ฐจ์ด
API
: ๋ค๋ฅธ SW์์ ๊ฐ๋ฐ์ค์ธ sw๋ฅผ ์ฌ์ฉํ๋๋ก ์ ์๋ interface์
๋๋ค. ๋ค๋ฅธ ํ๋ก๊ทธ๋๋จธ๊ฐ ์์ฑํ ์ฝ๋๋ฅผ ๋ค๋ฅธ ๊ฐ๋ฐ์๊ฐ ์ฝ๊ฒ ์ด์ฉํ๋๋ก ๋ง๋ ์ธํฐํ์ด์ค์
๋๋ค.
๋ผ์ด๋ธ๋ฌ๋ฆฌ
๋ ์ฝ๋์ ๋ชจ์์ด๊ณ ๊ฐ๋ฐ์์ ์ํด ํน์ ๊ธฐ๋ฅ์ ์ฝ๊ฒ ๊ตฌํํ ์ ์๊ฒํด์ฃผ๋๊ฒ.
ํ๋ ์์ํฌ
์ฝ๋, ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์งํฉ์ด๊ณ , ๊ฐ๋ฐ์๊ฐ ๋ชจ๋ ์์ฑ๊ณผ ๊ตฌ์กฐ๋ฅผ ๋ง๋ค๊ฑฐ๋ ์์ ํ๋ ๊ฒ์ด ์๋ ์ผ๋ถ ๊ท๊ฒฉ์ ๋ฐ๋ฅด๊ฑฐ๋, ํ๋ ์์ํฌ์๊ฒ ์๋ช
์ฃผ๊ธฐ๋ฅผ ์์ํจ์ผ๋ก์จ ๋ก์ง์ ์ข๋ ์ง์คํ๋๋ก ๋์์ฃผ๋ ๊ฒ.
๋ถ๋ณ๊ฐ์ฒด ๊ฐ๋ณ ๊ฐ์ฒด
๋ถ๋ณ๊ฐ์ฒด
๊ฐ์ฒด ์์ฑ ์ดํ ์ํ๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ ๊ฐ์ฒด = String, ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์ ์์ ํ๊ฒ ๊ฐ์ฒด๋ฅผ ๊ณต์ ํ ์ ์๋ค.
๊ฐ๋ณ๊ฐ์ฒด
๊ฐ์ฒด ์์ฑ์ดํ ์ํ๋ฅผ ๋ณ๊ฒฝํ ์์๋ ๊ฐ์ฒด = ArrayList, ์ค๋ ๋ safe ํ์ง์๋ค.
์ง๋ ฌํ vs ์ญ์ง๋ ฌํ
์ง๋ ฌํ
: ์๋ฐ ์์คํ
๋ด๋ถ์์ ์ฌ์ฉ๋๋ ๊ฐ์ฒด ๋๋ ๋ฐ์ดํฐ๋ฅผ ์ธ๋ถ์ ์๋ฐ ์์คํ
์์๋ ์ฌ์ฉํ ์ ์๋๋ก ๋ฐ์ดํธ(byte) ํํ๋ก ๋ฐ์ดํฐ ๋ณํํ๋ ๊ธฐ์ .
์บ์์ ์๋ธ๋ฆฟ ์ธ์
์ ์๋ก ๋ค์ ์์ต๋๋ค.
์ง๋ ฌํ๋ฅผ ์ฌ์ฉํ์ง ์๋ ์ด์ :
์ง๋ ฌํ ๋ฐ์ดํฐ๋ ํ์
, ํด๋์ค ๋ฉํ์ ๋ณด๋ฅผ ํฌํจํ๋ฏ๋ก ์ฌ์ด์ฆ๊ฐ ํฌ๋ค. ํธ๋ํฝ์ ๋ฐ๋ผ ๋น์ฉ ์ฆ๊ฐ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๊ธฐ ๋๋ฌธ์ JSON ํฌ๋งท์ผ๋ก ๋ณ๊ฒฝํ๋ ๊ฒ์ด ์ข๋ค
์ด์งํ์ ์๊ฐ๋ณต์ก๋
์ด์ง ํ์
์ ์ ๋ ฌ์ด ๋์ด์๋ค๋ ๊ฐ์ ํ์, ์ค์๋ถํฐ ๊ฐ์ ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ์
๋๋ค.
O(logn) ๋น๊ต๋ก ์ํ๋ ๊ฐ์ ์ฐพ์ ๊ฐ ์ ์์. ์ด๋ก ์ธํด ์ฝ์
, ์ญ์ ์ด๋ฒคํธ ๋ฐ์์ ๋ฑ ์ถ๊ฐ์ ์ธ ์์
์ด ํ์ํจ.
๋ณํฉ ์ ๋ ฌ, ํต์ ๋ ฌ
๋๋ค divide & conquer ์๊ณ ๋ฆฌ์ฆ์
๋๋ค. ๋๋ค ํ๊ท ์๊ฐ๋ณต์ก๋๋ O(nlogn)
์
๋๋ค.
ํต์ ๋ ฌ์ ์ต์
์ผ ๊ฒฝ์ฐ์๋ O(n^2)์ด๊ณ ๋ณํฉ์ ํญ์ nlogn ์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋๋ค.
์๋ฐ๋ ARRAY์ ๊ฒฝ์ฐ ๋์ผ ํผ๋ด, Collections์๋ Tim sort๋ฅผ ์ฌ์ฉํฉ๋๋ค.(๋ณํฉ์ ๋ ฌ+์ฝ์
์ ๋ ฌ)
ํ๋ก์ธ์ค์ ์ค๋ ๋, ๋ฉํฐ ํ๋ก์ธ์ค, ๋ฉํฐ์ค๋ ๋
ํ๋ก์ธ์ค
๋ OS์ ์คํ๋๋ ํ๋ก๊ทธ๋จ์ ๋จ์์
๋๋ค. ์ค๋ ๋
๋ ํ๋ก์ธ์ค ๋ด๋ถ ์คํ ๋จ์์
๋๋ค.
๋ฉํฐ ํ๋ก์ธ์ค
๋ ์ฌ๋ฌ ๊ฐ์ ํ๋ก์ธ์ค๋ฅผ ๋์์ ์คํํ๋ ๊ฒ์ ๋งํ๋ฉฐ, ๊ฐ ํ๋ก์ธ์ค๋ ๋
๋ฆฝ์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋น๋ฐ์ ์คํ๋ฉ๋๋ค. ๋ฐ๋ผ์ IPC๋ฅผ ์ด์ฉํด ํ๋ก์ธ์ค ๊ฐ์ ํต์ ํด์ผ ํฉ๋๋ค.
๋ฉํฐ ์ค๋ ๋
๋ ํ๋์ ํ๋ก์ธ์ค ๋ด์์ ์ฌ๋ฌ ๊ฐ์ ์ค๋ ๋๋ฅผ ๋์์ ์คํํ๋ ๊ฒ์ ๋งํ๋ฉฐ, ๊ฐ ์ค๋ ๋๋ ํ๋ก์ธ์ค ๋ด์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณต์ ํ๋ฉด์ ์คํ๋ฉ๋๋ค. ์ด๋ฌํ ๋ฉํฐ ์ค๋ ๋๋ ํ๋ก์ธ์ค ๊ฐ ํต์ ์ด ํ์ํ์ง ์๊ธฐ ๋๋ฌธ์, ๋ฉํฐ ํ๋ก์ธ์ค๋ณด๋ค ๋ ๋น ๋ฅด๊ณ ๊ฒฝ์ ์ ์ผ๋ก ๋์ํ ์ ์์ต๋๋ค.
IPC(Inter-Process Communication)๋ ๋ฌด์์ธ๊ฐ?
IPC(Inter-Process Communication)
๋ ์๋ก ๋ค๋ฅธ ํ๋ก์ธ์ค ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ๊ธฐ์ ์ ๋งํฉ๋๋ค. ํ๋ก์ธ์ค ๊ฐ์ ํต์ ์ ํ ๋๋ IPC๋ฅผ ์ด์ฉํด์ผ ํฉ๋๋ค. ์ด๋ ํ๋ก์ธ์ค๊ฐ ์๋ก ๋
๋ฆฝ์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ์ง๊ธฐ ๋๋ฌธ์, ๊ฐ ํ๋ก์ธ์ค๊ฐ ๊ฐ์ง ์์์ ๊ณต์ ํ๊ฑฐ๋, ํ๋ก์ธ์ค ๊ฐ์ ๋ฐ์ดํฐ ์ ๋ฌ์ด ํ์ํ ๋ ์ฌ์ฉ๋ฉ๋๋ค.
IPC ๊ธฐ์ ์๋ ํ์ดํ, ๋ฉ์์ง ํ, ๊ณต์ ๋ฉ๋ชจ๋ฆฌ
๋ฑ์ด ์์ต๋๋ค.
ํ์ดํ(Pipe)
๋ ์ผ๋ฐฉํฅ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๋๋ฐ ์ฌ์ฉ๋๋ฉฐ, ๋ถ๋ชจ์ ์์ ํ๋ก์ธ์ค ๊ฐ์ ํต์ ์ ์ฌ์ฉ๋ฉ๋๋ค.
e.g) ๋ถ๋ชจ P -> ์์ P or ์์ P -> ๋ถ๋ชจ P
๋ฉ์์ง ํ(Message Queue)
๋ ์ฐํธํจ๊ณผ ๊ฐ์ ์ญํ ๋ก, ์ฌ๋ฌ ํ๋ก์ธ์ค๊ฐ ๋ฉ์์ง๋ฅผ ํ์ ๋ณด๋ด๊ณ ๋ฐ์์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌํ ์ ์์ต๋๋ค.
e.g) , ์๋ฒ์์ ํด๋ผ์ด์ธํธ๋ก ๋ฉ์์ง๋ฅผ ์ ์กํ๊ฑฐ๋, ๋ค๋ฅธ ์ดํ๋ฆฌ์ผ์ด์
์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌํ๋ ๋ฑ์ ๊ฒฝ์ฐ์ ๋ฉ์์ง ํ๊ฐ ์ฌ์ฉ
๊ณต์ ๋ฉ๋ชจ๋ฆฌ(Shared Memory
)๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ณต์ ํ๋ ๊ฒ์ผ๋ก, ํ๋์ ํ๋ก์ธ์ค๊ฐ ๊ณต์ ๋ฉ๋ชจ๋ฆฌ์ ๋ฐ์ดํฐ๋ฅผ ์ฐ๋ฉด, ๋ค๋ฅธ ํ๋ก์ธ์ค์์๋ ํด๋น ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ฌ ์ ์์ต๋๋ค.
e.g) ๋ฐ์ดํฐ๋ฒ ์ด์ค ์๋ฒ์์ ๋ค๋ฅธ ์ดํ๋ฆฌ์ผ์ด์
์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌํ๊ฑฐ๋, ์น ์๋ฒ์์ ๋ฐฑ๊ทธ๋ผ์ด๋ ์์
์ ์ฒ๋ฆฌํ๋ ๋ฑ์ ๊ฒฝ์ฐ์ ๊ณต์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ฌ์ฉ
IPC๋ฅผ ์ด์ฉํ๋ฉด, ๊ฐ๊ฐ ๋ ๋ฆฝ์ ์ผ๋ก ์คํ๋๋ ํ๋ก์ธ์ค ๊ฐ์ ๋ฐ์ดํฐ ์ ๋ฌ์ด ๊ฐ๋ฅํด์ง๋ฏ๋ก, ํ๋ก์ธ์ค ๊ฐ ํ๋ ฅ์ด ํ์ํ ๋ค์ํ ํ๋ก๊ทธ๋จ์์ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฐ์ดํฐ๋ฒ ์ด์ค ์๋ฒ์์ ๋ค๋ฅธ ์ดํ๋ฆฌ์ผ์ด์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌํ๊ฑฐ๋, ์น ์๋ฒ์์ ๋ฐฑ๊ทธ๋ผ์ด๋ ์์ ์ ์ฒ๋ฆฌํ๋ ๋ฑ์ ๊ฒฝ์ฐ์ IPC๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
๋ฎคํ ์ค ์ธ๋งํฌ์ด ๋ชจ๋ํฐ๋ฝ
๋ฎคํ
์ค
๋ฝ๊ณผ ์ธ๋ฝ์ ํตํด ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ ๋๊ธฐํ ๊ธฐ๋ฒ์
๋๋ค.
์๊ณ ๊ตฌ์ญ(critical section)์ ํ๋์ ์ค๋ ๋๋ง ์ง์
ํ ์ ์๋๋ก ํฉ๋๋ค.
๋ฎคํ
์ค๋ ํ๋์ ์ค๋ ๋๋ง ์๊ณ ๊ตฌ์ญ์ ์ง์
ํ๋๋ก ๋ณด์ฅํ์ง๋ง, ๊ณต์ ์์์ ๋ํ ๋๊ธฐํ๊ฐ ํ์ํ ๊ฒฝ์ฐ์๋ ์ธ๋งํฌ์ด๋ฅผ ์ฌ์ฉํฉ๋๋ค.
์ธ๋งํฌ์ด
๋ ๋ฎคํ
์ค์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋๊ธฐํ ๊ธฐ๋ฒ ์ค ํ๋์
๋๋ค.
๊ณต์ ์์์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์นด์ดํฐ์ wait, signal ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค.
wait ๋ฉ์๋๋ ์นด์ดํฐ๋ฅผ ๊ฐ์์ํค๊ณ , ์นด์ดํฐ๊ฐ 0์ด๋ฉด ์ค๋ ๋๋ฅผ ๋๊ธฐ์ํต๋๋ค.
signal ๋ฉ์๋๋ ์นด์ดํฐ๋ฅผ ์ฆ๊ฐ์ํค๊ณ , ๋๊ธฐ ์ค์ธ ์ค๋ ๋ ์ค ํ๋๋ฅผ ๊นจ์๋๋ค.
๋ชจ๋ํฐ ๋ฝ
์ ๊ฐ์ฒด์ ๋ํ ์ํธ ๋ฐฐ์
๋ฅผ ์ํ ๋๊ธฐํ ๊ธฐ๋ฒ์
๋๋ค.
๋ชจ๋ํฐ ๋ฝ์ ์๋ฐ์์ synchronized ํค์๋๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํ๋ฉ๋๋ค.
๋ชจ๋ํฐ ๋ฝ์ ๋ฉ์๋๋ ๋ธ๋ก ๋จ์๋ก ์ ์ฉ๋๋ฉฐ, ๋ฝ์ ์ป์ ์ค๋ ๋๋ง ์๊ณ ๊ตฌ์ญ์ ์ง์
ํ ์ ์์ต๋๋ค.
๋ชจ๋ํฐ ๋ฝ์ ๋ฎคํ
์ค์ ๋ฌ๋ฆฌ ๋๊ธฐ ์ค์ธ ์ค๋ ๋์ ๋ํ ์ฐ์ ์์๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค.