๋๊ธฐ/๋น๋๊ธฐ๋?
๐ถ๋๊ธฐ๋(Synchronize)?
๐ฒ ์์ฒญ ์์ ์ ๋ํ ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ ธ ์์๋๋ก ์ฒ๋ฆฌํ๋ ๊ฒ์ ๋งํ๋ค.
๐ถ๋น๋๊ธฐ๋(Asynchronize)?
๐ฒ ์์ฒญ ์์ ์ ๋ํด ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ง์ง ์์, ์์ ์ ์์ ์ ๊ทธ๋๋ก ์คํํ๋ค.
๋๊ธฐ์ ๋น๋๊ธฐ์ ํฐ ์ฐจ์ด์ ์ค ํ๋๋ ์์ฒญํ ์์ ์ ๋ํด์ ์์ ์์๊ฐ ์ง์ผ์ง๋, ์ง์ผ์ง์ง ์๋์ด๋ค.
๋๊ธฐ๋ ์์ ์์๊ฐ ์ง์ผ์ง๊ธฐ ๋๋ฌธ์ A, B, C๋ผ๋ Task์ ๋ํด ๊ทธ ์์๋ฅผ ์งํค๋ฉฐ ์คํ๋์ง๋ง, ๋น๋๊ธฐ๋ ๊ทธ๋ ์ง ์๋ค. ๋ฌด์์๋ก ์คํ๋ ์ ์๋ ๊ฒ์ด๋ค.
๋ธ๋ญํน/๋ ผ๋ธ๋ญํน์ด๋?
๐ถ ๋ธ๋ญํน์ด๋?
๐ฒ ๋ค๋ฅธ ์์ฒญ์ ์์ ์ ์ฒ๋ฆฌํ๊ธฐ ์ํด ํ์ฌ ์์ ์ Block(์ฐจ๋จ)ํ๋ ๊ฒ
๐ถ ๋ ผ๋ธ๋ญํน์ด๋?
๐ฒ ๋ค๋ฅธ ์์ฒญ์ ์์ ์ ์ฒ๋ฆฌํ๊ธฐ ์ํด ํ์ฌ ์์ ์ Block(์ฐจ๋จ)ํ์ง ์๋ ๊ฒ
๐ค ๋ ผ๋ธ๋ญํน๊ณผ ๋น๋๊ธฐ์ ์ฐจ์ด์ ?
๋ ๊ฐ๋ ๋ชจ๋ ๊ฐ์ ์์ ์ ๋ค๋ฅธ ์์ ์ ์ํํ๋ค๋ ์ ์์๋ ๊ณตํต์ ์ ์ง๋๋ค. ์ด๋ฅผ ๊ตฌ๋ถํ๋ ๊ฒ์ ๋ฐ๋ผ๋ณด๋ ์๊ฐ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋ค. ์์ ์ ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ง์ง ์๊ณ ์์๋๋ก ์ํ๋๋๊ฐ์ ๊ด์ ์์ ๋ณธ๋ค๋ฉด ๋๊ธฐ/๋น๋๊ธฐ์ ๋ฐฉ์์ธ ๊ฒ์ด๊ณ , ํ์ฌ ์์ ์ด ์ฐจ๋จ๋๋์ ๊ด์ ์์ ๋ณธ๋ค๋ฉด ๋ธ๋ญํน/๋ ผ๋ธ๋ญํน์ ๋ฐฉ์์ธ ๊ฒ์ด๋ค.
๋๊ธฐ/๋น๋๊ธฐ์ ๋ธ๋ญํน/๋ ผ๋ธ๋ญํน์ ์กฐํฉ
Sync + Blocking(๋๊ธฐ + ๋ธ๋ญํน) ๋ฐฉ์
์์ ์ด ์งํ๋๋ ๋์, ์๊ธฐ ์์ ์ ์์ ์ Block(์ฐจ๋จ)ํ๊ณ , ๋ค๋ฅธ ์์ ์ ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ ์์๋๋ก ์งํํ๋ ๋ฐฉ์์ด๋ค.
์ผ๋ฐ์ ์ธ Spring MVC ๋ฐฉ์์์ Sync + Blocking ๋ฐฉ์์ ์ฌ์ฉํ๋ค.
Async + None-Blocking(๋น๋๊ธฐ + ๋ ผ๋ธ๋ญํน) ๋ฐฉ์
์์ ์ด ์งํ๋๋ ๋์์๋ Blockํ์ง ์๊ณ , ์๊ธฐ ์์ ์ ์งํํ๋ค. ๋์์ ๋ค๋ฅธ ์์ ์ ์์ ์์๋ฅผ ์งํค์ง ์๋๋ค. ์ด๋ฌํ ๊ฒฝ์ฐ, ๋ค๋ฅธ ์์ ์ด ์์ ์ ์์ ์ ์ํฅ์ ๋ผ์น์ง ์๋ ํธ์ด ์ข๋ค.
Node.js๊ฐ Async + None-Blocking ๋ฐฉ์์ผ๋ก ์๋๋๋ค. ํน์ @Async ์ด๋ ธํ ์ด์ ์ ์ฌ์ฉํ๋ฉด ์ ์ฌํ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
Sync + None-Blocking(๋๊ธฐ + ๋ ผ๋ธ๋ญํน) ๋ฐฉ์
๋ง์ฐฌ๊ฐ์ง๋ก, ์์ ์ด ์งํ๋๋ ๋์ ์๊ธฐ ์์ ์ Blockํ์ง ์๋๋ค. ๋ฐ๋ฉด ๋ค๋ฅธ ์์ ์ ์์ ์์๋ ์ง์ผ์ผ ํ๊ธฐ ๋๋ฌธ์ ์์ ์ ์๋ฃ ์ฌ๋ถ๋ฅผ ๊ณ์ํด์ ํ์ธํ๋ค.
Java์ Thread๋ฅผ ํตํด์ ํด๋น ์์ ์ ํ์ธํด ๋ณผ ์ ์๋ค.
class MyTask implements Runnable {
@Override
public void run() {
System.out.println("Thread ๋น๋๊ธฐ ์คํ ์ค...");
}
}
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(new MyTask());
thread.start();
System.out.println("Main Thread ์คํ ์ค...");
while(thread.isAlive()) {
System.out.println("thread๊ฐ ๋๋ ๋๊น์ง ๋๊ธฐ ์ค...");
}
System.out.println("Thread ์ข
๋ฃ!");
}
}
๋ณด์ด๋ค์ํผ Java์ Thread๋ ์๋ฃ ์ฌ๋ถ๋ฅผ ์ง์์ ์ผ๋ก ๋ฌผ์ด๋ด Sync๋ฅผ ์งํฌ ์ ์๋๋ก ํ๋ค.
Async + Blocking(๋น๋๊ธฐ + ๋ธ๋ญํน) ๋ฐฉ์
๋ค๋ฅธ ์์ ์ ์คํํ๋ ๋์ ์๊ธฐ ์์ ์ Blockํ๋ฉฐ, ์์ ์ ์๋ฃ ์์๋ฅผ ๋ฐ์ง์ง ์๋๋ค. ํ์ง๋ง Blockingํ๋ ๋ฐฉ์์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ์ค์ง์ ์ผ๋ก Sync + Blocking๋ฐฉ์๊ณผ ์ฐจ์ด๊ฐ ํฌ์ง ์๋ค.
MySQL + Node.js ๋ฐฉ์์์ ํด๋น ๋ฐฉ์์ด ์ฌ์ฉ๋์๊ธด ํ๋ค.
MySQL์ ๋๋ผ์ด๋ฒ๊ฐ Blocking๋ฐฉ์์ผ๋ก ์๋ํ๊ณ , Node.js๊ฐ Async๋ฐฉ์์ผ๋ก DB์ ์ ๊ทผํ๊ธฐ ๋๋ฌธ์ด๋ค.
References
WTF is Synchronous and Asynchronous!
Vote for next post or mention what do you want to see next here:
medium.com
[Reactive Programming] [1] - ๋๊ธฐ(Synchronous)์ ๋น๋๊ธฐ(Asynchronous), Blocking๊ณผ Non-Blocking
Reactive Programming์ ํ์ตํ๊ธฐ์ ์์ ์ฉ์ด๋ค์ ๋ํด ์์๋ณด๊ณ ์ ๋ฆฌํ๊ณ ์ ํฉ๋๋ค. ์ด๋ฒ ๊ธ์์๋ ๋๊ธฐ์ ๋น๋๊ธฐ, Blocking๊ณผ Non-Blocking์ ๋ํ์ฌ ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค. ๋งค์ฐ ํท๊ฐ๋ฆฌ๋ ๊ฐ๋ ๋ค์ด๊ณ ,
ttl-blog.tistory.com
๐ฉ๐ป ์๋ฒฝํ ์ดํดํ๋ ๋๊ธฐ/๋น๋๊ธฐ & ๋ธ๋กํน/๋ ผ๋ธ๋กํน
๋๊ธฐ/๋น๋๊ธฐ & ๋ธ๋กํน/๋ ผ๋ธ๋กํน ํ๋ก๊ทธ๋๋ฐ์์ ์น ์๋ฒ ํน์ ์ ์ถ๋ ฅ(I/O)์ ๋ค๋ฃจ๋ค ๋ณด๋ฉด ๋๊ธฐ/๋น๋๊ธฐ & ๋ธ๋กํน/๋ ผ๋ธ๋กํน ์ด๋ฌํ ์ฉ์ด๋ค์ ์ ํด๋ณธ ๊ฒฝํ์ด ํ๋ฒ ์ฏค์ ์์ ๊ฒ์ด๋ค. ๋๋ถ๋ถ ์ฌ๋๋ค์
inpa.tistory.com
'๐ซ Language > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ๋ชจ๋ ๊ฐ์ฒด๋ ๋ถ๋ณ ๊ฐ์ฒด์ฌ์ผ ํ ๊น? (0) | 2024.02.28 |
---|---|
[Java] ๊ฐ์ฒด ์งํฅ ์ค๊ณ 5์์น(SOLID)์ด๋? (2) | 2024.01.13 |
[Java] ์ผ๊ธ ์ปฌ๋ ์ ๊ณผ ์ฌ์ฉํด์ผ ํ๋ ์ด์ ์ ๋ํ์ฌ (2) | 2024.01.13 |
[Java] JUnit5 ์ฌ์ฉ๋ฒ ์์๋ณด๊ธฐ (0) | 2024.01.09 |
[Java] ๋ฉํฐ์ค๋ ๋์ ๋๊ธฐํ์ ๋ํด์ (1) | 2024.01.06 |