๐พ [CS] ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ด๋ ๋ฌด์์ผ๊น์?
- ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ์ฌ๋ฌ ์์ ์ ๋์์ ์ํํ ์ ์๋๋ก ํ๋ก๊ทธ๋จ์ ์ค๊ณํ๋ ๊ธฐ๋ฒ์ ๋๋ค.
- ๋์์ฑ(Concurrency)์ ์์ ์ ์คํ ํ๋ฆ์ ๊ฒน์น๊ฒ ํ๊ฑฐ๋ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ์ฌ, ์์คํ ์ ํจ์จ์ฑ์ ๋์ด๊ณ ์ฒ๋ฆฌ ์๊ฐ์ ์ค์ด๋ ๋ฐ ์ค์ ์ ๋ก๋๋ค.
- ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ๋ฉํฐ์ค๋ ๋ฉ, ๋ฉํฐํ๋ก์ธ์ฑ์ ํฌํจํ์ฌ, ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ๊ณผ ๊ฐ์ ๋ค์ํ ๊ธฐ๋ฒ์ ์ฌ์ฉํ์ฌ ์์คํ ์์์ ์ต๋ํ ํ์ฉํ ์ ์๋๋ก ํฉ๋๋ค.
1๏ธโฃ ๋์์ฑ๊ณผ ๋ณ๋ ฌ์ฑ์ ์ฐจ์ด.
- ๋์์ฑ๊ณผ ๋ณ๋ ฌ์ฑ์ ์ข ์ข ํผ๋๋์ง๋ง, ์๋ก ๋ค๋ฅธ ๊ฐ๋ ์ ๋๋ค.
1๏ธโฃ ๋์์ฑ(Concurrency)
-
๋์์ฑ(Concurrency)์ ์ฌ๋ฌ ์์
์ด ์คํ๋๋ ๊ฒ์ฒ๋ผ ๋ณด์ด๊ฒ ํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
- ์ค์ ๋ก๋ ์์ ๊ฐ์ ์คํ ์๊ฐ์ ์ชผ๊ฐ์ด ๋ฒ๊ฐ์ ๊ฐ๋ฉด์ ์คํํ์ฌ, ์ฌ๋ฌ ์์ ์ด ๋์์ ์งํ๋๋ ๊ฒ์ฒ๋ผ ๋ณด์ด๊ฒ ๋ง๋ญ๋๋ค.
- ์๋ฅผ ๋ค์ด, ํ๋์ CPU ์ฝ์ด์์ ๋ ๊ฐ์ ์์
์ ๋ฒ๊ฐ์๊ฐ๋ฉฐ ๋น ๋ฅด๊ฒ ์คํํ๋ฉด, ๋ ์์
์ด ๋์์ ์คํ๋๋ ๊ฒ์ฒ๋ผ ๋๊ปด์ง๋๋ค.
- ์ด๋ ๋ฉํฐํ์คํน(Multitasking)์ ๊ฐ๋ ๊ณผ ์ ์ฌํฉ๋๋ค.
2๏ธโฃ ๋ณ๋ ฌ์ฑ(Parallelism)
-
๋ณ๋ ฌ์ฑ(Parallelism)์ ์ฌ๋ฌ ์์
์ ๋์์ ์คํํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
- ๋์์ฑ๊ณผ ๋ฌ๋ฆฌ, ์ค์ ๋ก ์ฌ๋ฌ CPU ์ฝ์ด์์ ์ฌ๋ฌ ์์ ์ ๋์์ ์ฒ๋ฆฌํฉ๋๋ค.
- ๋ณ๋ ฌ์ฑ(Parallelism)์ ๋ฉํฐ์ฝ์ด ํ๋ก์ธ์ ํ๊ฒฝ์์ ์ฃผ๋ก ์ด๋ฃจ์ด์ง๋ฉฐ, ํ๋์ ์์ ์ ์ฌ๋ฌ ์กฐ๊ฐ์ผ๋ก ๋๋ ์ฌ๋ฌ ์ฝ์ด์์ ๋์์ ์ฒ๋ฆฌํ ์ ์๊ฒ ํด์ค๋๋ค
2๏ธโฃ ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ํ์์ฑ
1๏ธโฃ ํจ์จ์ ์ธ ์์ ์ฌ์ฉ.
- ์ปดํจํฐ ์์คํ
์ CPU, ๋ฉ๋ชจ๋ฆฌ, I/O ์ฅ์น์ ๊ฐ์ ๋ค์ํ ์์์ด ์์ต๋๋ค.
- ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ํตํด ์ด๋ฌํ ์์์ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ ์ ์์ต๋๋ค.
- ์๋ฅผ ๋ค์ด, ํ์ผ์ ์ฝ๊ฑฐ๋ ๋คํธ์ํฌ ์์ฒญ์ ๊ธฐ๋ค๋ฆฌ๋ ๋์ CPU๊ฐ ์ ํ ์ํ์ ๋จธ๋ฌด๋ฅด์ง ์๋๋ก, ๋ค๋ฅธ ์์ ์ ์คํํ ์ ์์ต๋๋ค.
๐ ์ ํ ์ํ(Idle State)
CPU๊ฐ ํ์ฌ ์คํํ ์์ ์ด ์์ด์ ๋๊ธฐํ๊ณ ์๋ ์ํ๋ฅผ ์๋ฏธํฉ๋๋ค.
์ฆ, CPU๊ฐ ์๋ฌด๋ฐ ์์ ๋ ์ํํ์ง ์๊ณ ์ฌ๊ณ ์๋ ์ํ๋ฅผ ๋ปํฉ๋๋ค.์ปดํจํฐ ์์คํ ์์ CPU๋ ํญ์ ์์ ์ ํ ๋น๋ฐ์์ผ ์ ๋๋ก ์๋ํ ์ ์์ต๋๋ค.
๊ทธ๋ฌ๋ ์ ์ถ๋ ฅ ์์ ์ด ์๋ฃ๋๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฌ๊ฑฐ๋, ๋ค์ ๋ช ๋ น์ด๊ฐ ์ค๋น๋์ง ์์ ๊ฒฝ์ฐ ๋ฑ, ํน์ ์ํฉ์์๋ CPU๊ฐ ์ ํ ์ํ๋ก ๋จธ๋ฌผ๊ฒ ๋ฉ๋๋ค.
2๏ธโฃ ๋น ๋ฅธ ์๋ต์ฑ.
- ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ํ๋ก๊ทธ๋จ์ ์๋ต์ฑ์ ํฅ์์ํต๋๋ค.
- ์๋ฅผ ๋ค์ด, ์ฌ์ฉ์๊ฐ ๋ฒํผ์ ํด๋ฆญํ ๋๋ง๋ค ์๋ก์ด ์์ฒญ์ด ์ฒ๋ฆฌ๋๋๋ก ํ๊ณ , ๋ฉ์ธ ์ค๋ ๋๊ฐ ๋ค๋ฅธ ์์ ์ ์ํํ๋ ๋์์๋ UI๊ฐ ๋ฉ์ถ์ง ์๊ฒ ํ ์ ์์ต๋๋ค.
- ์ด๋ ํนํ ์น ์๋ฒ์ ๊ฐ์ ํ๊ฒฝ์์ ์ค์ํฉ๋๋ค.
- ์ฌ๋ฌ ์ฌ์ฉ์์ ์์ฒญ์ ๋์์ ์ฒ๋ฆฌํ์ฌ ๋น ๋ฅด๊ฒ ์๋ตํ ์ ์์ต๋๋ค.
3๏ธโฃ ๋ฐฐ์น ์ฒ๋ฆฌ ๋ฐ ๋ณ๋ ฌ ๊ณ์ฐ.
- ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ๋๋์ ๋ฐ์ดํฐ๋ฅผ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ ๋ ์ ๋ฆฌํฉ๋๋ค.
- ์๋ฅผ ๋ค์ด, ๋น ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํด ์ฌ๋ฌ ๋ ธ๋์์ ๋ฐ์ดํฐ๋ฅผ ๋์์ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
๐ ๋ ธ๋(Node)
์ปดํจํฐ ๋คํธ์ํฌ์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ฑฐ๋ ์ ์กํ๋ ์ฅ์น๋ ์์คํ ์ ์๋ฏธํฉ๋๋ค.
๋ ธ๋๋ ๋คํธ์ํฌ๋ฅผ ๊ตฌ์ฑํ๋ ๊ฐ๋ณ์ ์ธ ์ฅ์น๋ก, ์๋ฒ, ์ปดํจํฐ, ๋ผ์ฐํฐ, ์ค์์น, ๋๋ ํด๋ผ์ด์ธํธ ๋ฑ์ด ๋ชจ๋ ๋ ธ๋๊ฐ ๋ ์ ์์ต๋๋ค.
๋ถ์ฐ ์์คํ ์์ ๋ ธ๋๋ ๊ฐ๊ฐ ๋ ๋ฆฝ์ ์ผ๋ก ์์ ์ ์ํํ๊ฑฐ๋, ์๋ก ํ๋ ฅํ์ฌ ํฐ ์์ ์ ๋ถ๋ดํ ์ ์์ต๋๋ค.
3๏ธโฃ ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ์ฃผ์ ๊ฐ๋ .
1๏ธโฃ ์ค๋ ๋(Thread)
- ์ค๋ ๋๋ ํ๋ก์ธ์ค ๋ด์์ ์คํ๋๋ ์์ ์คํ ๋จ์์
๋๋ค.
- ํ ํ๋ก์ธ์ค๋ ์ฌ๋ฌ ์ค๋ ๋๋ฅผ ๊ฐ์ง ์ ์์ผ๋ฉฐ, ์ด๋ค ์ค๋ ๋๋ ๋ฉ๋ชจ๋ฆฌ์ ์์์ ๊ณต์ ํฉ๋๋ค.
- ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์์ ๋ฉํฐ์ค๋ ๋ฉ(Multithreading)์ ํตํด ์ฌ๋ฌ ์ค๋ ๋๋ฅผ ๋์์ ์คํํ์ฌ ์์ ์ ๋์์ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
2๏ธโฃ ๋ฝ(Lock)
- ์ฌ๋ฌ ์ค๋ ๋๊ฐ ๊ณต์ ์์์ ๋์์ ์ ๊ทผํ๋ฉด ๋ฐ์ดํฐ ์ถฉ๋(Race Condition)์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
- ์ด๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด, ๊ณต์ ์์์ ์ ๊ทผํ ๋ ๋ฝ์ ์ฌ์ฉํ์ฌ ํ ๋ฒ์ ํ๋์ ์ค๋ ๋๋ง ์์์ ์ ๊ทผํ๋๋ก ํฉ๋๋ค.
- ํ์ง๋ง ๋ฝ์ ์๋ชป ์ฌ์ฉํ ๊ฒฝ์ฐ ๋ฐ๋๋ฝ(DeadLock)์ด๋ ๋ผ์ด๋ธ๋ก(Livelock) ๊ฐ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ค๋ฏ๋ก, ์ฃผ์๊ฐ ํ์ํฉ๋๋ค.
3๏ธโฃ ๋ฎคํ ์ค(Mutex)์ ์ธ๋งํฌ์ด(Semaphore)
-
๋ฎคํ
์ค(Mutex)๋ ๋ ๊ฐ ์ด์์ ์ค๋ ๋๊ฐ ๋์์ ์์์ ์ ๊ทผํ๋ ๊ฒ์ ๋ฐฉ์งํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ๋ฝ์ ์ผ์ข
์
๋๋ค.
- ํน์ ์ค๋ ๋๊ฐ ์์์ ์ฌ์ฉํ๋ฉด, ๋ค๋ฅธ ์ค๋ ๋๋ ๊ทธ ์์์ด ํด์ ๋ ๋๊น์ง ๋๊ธฐํด์ผ ํฉ๋๋ค.
-
์ธ๋งํฌ์ด(Semaphore)๋ ๋ฆฌ์์ค์ ์ ๊ทผ ๊ฐ๋ฅํ ์๋์ ๊ด๋ฆฌํ์ฌ, ์ฌ๋ฌ ์ค๋ ๋๊ฐ ๋ฆฌ์์ค๋ ์ ๊ทผํ๋๋ก ์ ์ดํ ์ ์์ต๋๋ค.
- ์ ํ๋ ์์ ์ค๋ ๋๋ง ๋ฆฌ์์ค์ ์ ๊ทผํ ์ ์๊ฒ๋ ํ์ฉํฉ๋๋ค.
4๏ธโฃ ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ(Asynchronous Programming)
- ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ(Asynchronous Programming)์ ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ํ ํํ๋ก, ํน์ ์์ ์ด ์๋ฃ๋ ๋ ๊น์ง ๋๊ธฐํ์ง ์๊ณ ๋ค๋ฅธ ์์ ์ ๋จผ์ ์ํํ๋๋ก ํฉ๋๋ค.
- ์๋ฅผ ๋ค์ด, ๋คํธ์ํฌ ์์ฒญ์ ๋ณด๋ด๊ณ ์๋ต์ ๊ธฐ๋ค๋ฆฌ๋ ๋์, ํ๋ก๊ทธ๋จ์ ๋ค๋ฅธ ์์ ์ ์ํํ ์ ์์ต๋๋ค.
- Java์์๋
CompletableFuture
, JavaScript์์๋Promise
๋ฅผ ์ฌ์ฉํ์ฌ ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ(Asynchronous Programming)์ ์ฝ๊ฒ ๊ตฌํํ ์ ์์ต๋๋ค.
4๏ธโฃ ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ์์.
1๏ธโฃ ๋ฉํฐ์ค๋ ๋ฉ ์์.
class MyThread extends Thread {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + ": " + i);
try {
Thread.sleep(500); // 0.5์ด ๋๊ธฐ
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MYThread();
t1.start(); // t1 ์ค๋ ๋ ์์
t2.start(); // t2 ์ค๋ ๋ ์์
}
}
- ์ ์ฝ๋๋ ๋ ๊ฐ์ ์ค๋ ๋๋ฅผ ์์ฑํ๊ณ , ๋์์ ์คํ์์ผ ๋์์ฑ์ ๊ตฌํํ๋ ์์์ ๋๋ค.
2๏ธโฃ ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ ์์.
import java.util.concurrent.CompletableFuture;
public class AsyncExample {
public static void main(String[] args) {
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
try {
Thread.sleep(1000);
System.out.println("๋น๋๊ธฐ ์์
์๋ฃ!");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println("๋ฉ์ธ ์ค๋ ๋ ์์
์คํ ์ค...");
future.join(); // ๋น๋๊ธฐ ์์
์ด ๋๋ ๋๊น์ง ๋๊ธฐ
}
}
- ์ด ์ฝ๋๋ ๋น๋๊ธฐ์ ์ผ๋ก ์คํ๋๋ ์์ ์ ๋ง๋ค๊ณ , ๋ฉ์ธ ์ค๋ ๋๊ฐ ์์ ์ ๊ธฐ๋ค๋ฆฌ์ง ์๊ณ ๋ค๋ฅธ ์์ ์ ์ํํ ์ ์๊ฒ ํฉ๋๋ค.
5๏ธโฃ ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ์ฅ์ .
1๏ธโฃ ์์ ํจ์จ์ฑ ๊ทน๋ํ.
- CPU๊ฐ ์์ ์ ๋๊ธฐํ๋ ๋์ ์ ํด ์ํ๋ก ์์ง ์๊ณ , ๋ค๋ฅธ ์์ ์ ์ํํ ์ ์์ด ์์คํ ์์์ ํจ์จ์ฑ์ ๋์ผ ์ ์์ต๋๋ค.
2๏ธโฃ ๋น ๋ฅธ ์๋ต์ฑ
- ์ฌ๋ฌ ์์ ์ ๋์์ ์ํํ๊ฑฐ๋, ํน์ ์์ ์ ๊ธฐ๋ค๋ฆฌ๋ ๋์์๋ ํ๋ก๊ทธ๋จ์ด ์๋ตํ ์ ์๋๋ก ํ์ฌ, ์ฌ์ฉ์์ ๊ฒฝํ์ ๊ฐ์ ํฉ๋๋ค.
3๏ธโฃ ๋ณ๋ ฌ ์ฒ๋ฆฌ
- ์ฌ๋ฌ ์ฝ์ด๋ฅผ ์ฌ์ฉํ๋ ๋ฉํฐ์ฝ์ด ํ๋ก์ธ์ ํ๊ฒฝ์์ ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ํตํด ์์ ์๋๋ฅผ ํฌ๊ฒ ํฅ์์ํฌ ์ ์์ต๋๋ค.
6๏ธโฃ ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ๋จ์ .
1๏ธโฃ ๋ณต์ก์ฑ ์ฆ๊ฐ.
- ์ฌ๋ฌ ์ค๋ ๋๊ฐ ๋์์ ์์
์ ์ํํ ๋ ๋๊ธฐํ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ด, ํ๋ก๊ทธ๋จ์ ๋ณต์ก์ฑ์ด ์ฆ๊ฐํฉ๋๋ค.
- ๊ฐ๋ฐ์๋ ๋ฐ๋๋ฝ(DeadLock), ๋ ์ด์ค ์ปจ๋์ (Race Condition) ๋ฑ ์ฌ๋ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ผ ํฉ๋๋ค.
2๏ธโฃ ๋๋ฒ๊น ์ ์ด๋ ค์.
- ๋์์ฑ ์ฝ๋์ ๋๋ฒ๊น ์ ๋ค๋ฅธ ์๊ฒ์ ๋ฐ๋ผ ๋ค๋ฅธ ๊ฒฐ๊ณผ๊ฐ ๋ฐ์ํ ์ ์๊ธฐ ๋๋ฌธ์ ์์ธกํ๊ธฐ ์ด๋ ค์ด ๋ฒ๊ทธ๊ฐ ๋ํ๋ ์ ์์ต๋๋ค.
3๏ธโฃ ์ฑ๋ฅ ์ค๋ฒํค๋.
- ์ค๋ ๋๋ฅผ ์์ฑํ๊ณ ๊ด๋ฆฌํ๋ ๋ฐ์๋ ๋น์ฉ์ด ๋ฐ์ํ๋ฉฐ, ๋๊ธฐํ๋ฅผ ์ํด ๋ฝ์ ์ฌ์ฉํ๋ฉด ์ฑ๋ฅ์ด ์ ํ๋ ์ ์์ต๋๋ค.
6๏ธโฃ ์์ฝ.
- ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ ์ฌ๋ฌ ์์ ์ ๋์์ ์ํํ ์ ์๋๋ก ์ค๊ณ๋ ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ์์ผ๋ก, ๋ฉํฐ์ค๋ ๋ฉ(Multilthreading), ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ(Asyncronous Programming), ๋ฉํฐํ๋ก์ธ์ฑ(Multiprocessing)์ ํฌํจํ์ฌ ์์คํ ์์์ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ๊ณ ํ๋ก๊ทธ๋จ์ ์๋ต์ฑ์ ๋์ด๋ ๊ฒ์ ๋ชฉํ๋ก ํฉ๋๋ค.
- ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ(Concurrency Programming)์ CPU๊ฐ ์์
์ ๋๊ธฐํ๋ ๋์ ์ ํด ์ํ๋ก ์์ง ์๊ณ , ๋ค๋ฅธ ์์
์ ์ํํ์ฌ ์ฑ๋ฅ์ ์ต์ ํํฉ๋๋ค.
- ๊ทธ๋ฌ๋ ์ฝ๋์ ๋ณต์ก์ฑ, ๋๋ฒ๊น ์ ์ด๋ ค์, ์ฑ๋ฅ ์ค๋ฒํค๋ ๋ฑ๊ณ ํจ๊ป ๊ณ ๋ คํด์ผ ํฉ๋๋ค.