Block_Sync
๋ธ๋กํน๊ณผ ๋
ผ๋ธ๋กํน์ ์ฐจ์ด๋ ๋ฌด์์ธ๊ฐ์?
์ค์ ์ฉ์ด
์ ์ด๊ถ
์ ์ด๊ถ์ ์์ ์ ์ฝ๋(ํจ์)๋ฅผ ์คํํ ๊ถ๋ฆฌ ๊ฐ์ ๊ฒ์ผ๋ก, ์ ์ด๊ถ์ ๊ฐ์ง ํจ์๋ ์์ ์ ์ฝ๋๋ฅผ ๋๊น์ง ์คํํ ํ, ์์ ์ ํธ์ถํ ํจ์์๊ฒ ๋๋ ค์ค๋ค.
๊ฒฐ๊ณผ๊ฐ์ ๊ธฐ๋ค๋ฆฐ๋ค.
A ํจ์์์ B ํจ์๋ฅผ ํธ์ถํ์ ๋, A ํจ์๊ฐ B ํจ์์ ๊ฒฐ๊ด๊ฐ์ ๊ธฐ๋ค๋ฆฌ๋๋์ ์ฌ๋ถ๋ฅผ ์๋ฏธํ๋ค.
๋ธ๋กํน(Blocking)
๋ธ๋กํน์ A ํจ์๊ฐ B ํจ์๋ฅผ ํธ์ถํ๋ฉด, ์ ์ด๊ถ์ A๊ฐ ํธ์ถํ B ํจ์์ ๋๊ฒจ์ฃผ๋ ๋ฐฉ์์ด๋ค.

A ํจ์๊ฐ B ํจ์๋ฅผ ํธ์ถํ๋ฉด B์๊ฒ ์ ์ด๊ถ์ ๋๊ธด๋ค.
์ ์ด๊ถ์ ๋๊ฒจ๋ฐ์ B๋ ํจ์๋ฅผ ์คํํ๋ค. A๋ B์๊ฒ ์ ์ด๊ถ์ ๋๊ฒผ๊ธฐ ๋๋ฌธ์ ํจ์ ์คํ์ ์ ์ ๋ฉ์ถ๋ค.(
Block)B ํจ์๋ ์คํ์ด ๋๋๋ฉด ์์ ์ ํธ์ถํ A ํจ์์๊ฒ ์ ์ด๊ถ์ ๋๋ ค์ค๋ค.
์ ์ด๊ถ์ ๋ค์ ๋ฐ์ A ํจ์๋ ๊ทธ ๋ค์ ์์ ์ ์คํํ๋ค.
๋
ผ๋ธ๋กํน(Non-Blocking)
๋ ผ๋ธ๋กํน์ A ํจ์๊ฐ B ํจ์๋ฅผ ํธ์ถํด๋ ์ ์ด๊ถ์ ๊ทธ๋๋ก ์์ ์ด ๊ฐ์ง๊ณ ์๋ ๋ฐฉ์์ด๋ค.

A ํจ์๊ฐ B ํจ์๋ฅผ ํธ์ถํ๋ฉด, B ํจ์๋ ์คํ๋์ง๋ง, ์ ์ด๊ถ์ A ํจ์๊ฐ ๊ทธ๋๋ก ๊ฐ์ง๊ณ ์๋๋ค.
A ํจ์๋ ๊ณ์ ์ ์ด๊ถ์ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์ B ํจ์๋ฅผ ํธ์ถํ ์ดํ์๋ ์์ ์ ์ฝ๋๋ฅผ ๊ณ์ ์คํํ๋ค.
๋๊ธฐ์ ๋น๋๊ธฐ์ ์ฐจ์ด๋ ๋ฌด์์ธ๊ฐ์?
์ค์ ์ฉ์ด
์ ์ด๊ถ
์ ์ด๊ถ์ ์์ ์ ์ฝ๋(ํจ์)๋ฅผ ์คํํ ๊ถ๋ฆฌ ๊ฐ์ ๊ฒ์ผ๋ก, ์ ์ด๊ถ์ ๊ฐ์ง ํจ์๋ ์์ ์ ์ฝ๋๋ฅผ ๋๊น์ง ์คํํ ํ, ์์ ์ ํธ์ถํ ํจ์์๊ฒ ๋๋ ค์ค๋ค.
๊ฒฐ๊ณผ๊ฐ์ ๊ธฐ๋ค๋ฆฐ๋ค.
A ํจ์์์ B ํจ์๋ฅผ ํธ์ถํ์ ๋, A ํจ์๊ฐ B ํจ์์ ๊ฒฐ๊ด๊ฐ์ ๊ธฐ๋ค๋ฆฌ๋๋์ ์ฌ๋ถ๋ฅผ ์๋ฏธํ๋ค.
๋๊ธฐ(Synchronous)
์์ฒญ์ ๋ณด๋ด๊ณ ์คํ์ด ๋๋๋ฉด ๋ค์ ๋์์ ์ฒ๋ฆฌํ๋ ๋ฐฉ์
์ฆ, ์์ฒญํ ์์ ์ ๋ํด ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ ธ ์์ฐจ๋๋ก ์ฒ๋ฆฌํ๋ ๊ฒ์ ๋งํ๋ค.
์์์ ๋ง์ถ์ด ์งํ๋๊ธฐ ๋๋ฌธ์ ์ ์ดํ๊ธฐ ์ฝ๋ค.
์ฌ๋ฌ๊ฐ์ง ์์ฒญ์ ๋์์ ์ฒ๋ฆฌํ ์ ์์ด ํจ์จ์ด ๋จ์ด์ง๋ค.
์) ์ฝ์ผํฐ : ์ฝ์ผํฐ๋ ํ ์๋์ ์ ํ ์๋๊ฐ ๋๋ ํ์ ๋ค์ ์๋์ ์๋๋ฅผ ์งํํ ์ ์๋ค.
๋น๋๊ธฐ(Asynchronous)
์์ฒญ์ ๋ณด๋ด๊ณ ํด๋น ๋์์ ์ฒ๋ฆฌ ์ฌ๋ถ์ ์๊ด์์ด ๋ค์ ์์ฒญ์ด ๋์ํ๋ ๋ฐฉ์
๋๊ธฐ์ ๋ฐ๋๋ก ์์ฒญํ ์์ ์ ๋ํด ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ง์ง ์๊ธฐ ๋๋ฌธ์ ์์ ์ ๋ค์ ์์ ์ ๊ทธ๋๋ก ์ํํ๊ฒ ๋๋ค.
์์ ์ด ์๋ฃ๋๋ ์๊ฐ์ ๊ธฐ๋ค๋ฆด ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ์์์ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
์์ ์ด ์๋ฃ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ์ดํ๊ธฐ ์ด๋ ต๋ค.
์) ์ด๋ฉ์ผ : ์ฐ๋ฆฌ๋ ์ด๋ฉ์ผ์ ๋ณด๋ด๊ณ ๋ต๋ณ์ ๋ฐ์ง ์๊ณ ๋ ์ด๋ฉ์ผ์ ๋ค์ ๋ณด๋ผ ์ ์๋ค.
๋๊ธฐ(Synchronous)๋ Process B๊ฐ ์๋ฃ๋์ด์ผ ๋ค์ ์์
์ ์ํํ๊ณ , ๋น๋๊ธฐ(Asynchronous)๋ Process B์ ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ง์ง ์๊ณ ๋ฐ๋ก ๋ค์ ์์
์ ์ํํ๋ค.
๋น๋๊ธฐ์ ์ฑ๋ฅ ์ด์
๋น๋๊ธฐ๋ ์์ฒญํ ์์ ์ ๋ํ์ฌ ์๋ฃ ์ฌ๋ถ๋ฅผ ์ ๊ฒฝ์ฐ์ง ์๊ณ ์์ ์ ๊ทธ๋ค์ ์์ ์ ์ํํ๋ค.
์ด๊ฒ์
I/O์์ ๊ณผ ๊ฐ์ ๋๋ฆฐ ์์ ์ด ๋ฐ์ํ ๋, ๊ธฐ๋ค๋ฆฌ์ง ์๊ณ ๋ค๋ฅธ ์์ ์ ์ฒ๋ฆฌํ๋ฉด์ ๋์์ ์ฒ๋ฆฌํ๋ฉฐ ๋ฉํฐ ์์ ์ ์งํํ ์ ์๋ค๋ ๊ฒ์ ๋ปํ๋ค.์ฆ, ๋น๋๊ธฐ๋ ์ ๋ฐ์ ์ธ ์์คํ ์ฑ๋ฅ ํฅ์์ ๋์์ ์ค ์ ์๋ค.

๋๊ธฐ์ ๋น๋๊ธฐ๋ ์์
์์ ์ฒ๋ฆฌ ์ฐจ์ด
๋๊ธฐ์ ๋น๋๊ธฐ์ ์ฐจ์ด๋ฅผ ์ฝ๊ฒ ๋งํ๋ฉด ์ฌ๋ฌ ๊ฐ์ ์์ฒญ ์์ ์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํ๋๋ ์๋๋์ ๋ฐ๋ฅธ ์ฐจ์ด๋ค.
๋๊ธฐ ์์ ์ ์์ฒญํ ์์ ์ ๋ํด ์์๊ฐ ์ง์ผ์ง๋ ๊ฒ์ด๊ณ , ๋น๋๊ธฐ ์์ ์ ์์๊ฐ ์ง์ผ์ง์ง ์์ ์ ์๋ค๋ ๊ฒ์ด๋ค.

A, B, C๋ผ๋ 3๊ฐ์ ์์ ์ ๊ฐ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ํํ์ ๋์ ๊ทธ๋ฆผ์ด๋ค.
๋๊ธฐ๋ ์์๋๋ก ์คํ๋๊ณ , ๋น๋๊ธฐ๋ ๋ฌด์์ ์์๋ก ์คํ๋๋ค.
๋๊ธฐ์ ๋น๋๊ธฐ, ๋ธ๋กํน๊ณผ ๋
ผ๋ธ๋กํน์ ์ฎ์ด์ ์ค๋ช
ํด ์ฃผ์ธ์.
๊ฐ๊ฐ์ ํผํฉํด์ ์ด ๋ค ๊ฐ์ง ๊ฒฝ์ฐ์ ์๋ก ํ์ฉํ ์ ์๋ค.

๋๊ธฐ-๋ธ๋กํน(Sync Blocking)
๋๊ธฐ-๋ ผ๋ธ๋กํน(Sync Non-Blocking)
๋น๋๊ธฐ-๋ธ๋กํน(Async Blocking)
๋น๋๊ธฐ-๋ ผ๋ธ๋กํน(Async Non-Blocking)
๋๊ธฐ-๋ธ๋กํน(Sync Blocking)
Sync Blocking์กฐํฉ์ ๋ค๋ฅธ ์์ ์ด ์งํ๋๋ ๋์ ์์ ์ ์์ ์ ์ฒ๋ฆฌํ์ง ์๊ณ (Blocking), ๋ค๋ฅธ ์์ ์ ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ (Sync) ๋ฐฉ์์ด๋ค.๋ค๋ฅธ ์์ ์ ๊ฒฐ๊ณผ๊ฐ ์์ ์ ์์ ์ ์ํฅ์ ์ฃผ๋ ๊ฒฝ์ฐ์ ํ์ฉํ ์ ์๋ค.

๋๊ธฐ-๋ธ๋กํน ๋ฐฉ์์ ์์ ๋์ด ๋ง๊ฑฐ๋ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ์์ ์ ์ฒ๋ฆฌํด์ผ ํ๋ ๊ฒฝ์ฐ์๋ ์ข์ง ์๋ค.
์๋ํ๋ฉด ์์ ์ ์ฒ๋ฆฌํ๊ธฐ ์์ํ๋ฉด ์์ ์ด ๋๋ ๋๊น์ง ๋ค๋ฅธ ์์ ์ ์ฒ๋ฆฌํ์ง ๋ชปํ๋ฏ๋ก, ์ ์ฒด ์ฒ๋ฆฌ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๊ฒ ๋์ด ๋นํจ์จ์ ์ด๊ฒ ๋๋ค.
์ด ๊ฒฝ์ฐ ๋น๋๊ธฐ-๋ ผ๋ธ๋กํน ๋ฐฉ์์ผ๋ก ์์ ์ ์ฒ๋ฆฌํ๋ ๊ฒ์ด ์ข๋ค.
๋๊ธฐ-๋
ผ๋ธ๋กํน(Sync Non-Blocking)
Sync Non-Blocking์กฐํฉ์ ๋ค๋ฅธ ์์ ์ด ์งํ๋๋ ๋์์๋ ์์ ์ ์์ ์ ์ฒ๋ฆฌํ๊ณ (Non-Blocking), ๋ค๋ฅธ ์์ ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ๋ก ์ฒ๋ฆฌํ์ฌ ์์ ์ ์์ฐจ๋๋ก ์ํ ํ๋(Sync) ๋ฐฉ์์ด๋ค.

A ํจ์๋ B ํจ์์ ๋ฆฌํด๊ฐ์ด ํ์ํ๊ธฐ ๋๋ฌธ์ ์ค๊ฐ์ค๊ฐ B ํจ์์๊ฒ ํจ์ ์คํ์ ์๋ฃํ๋์ง ๋ฌผ์ด๋ณธ๋ค.
์ฆ, ๋ ผ๋ธ๋กํน์ธ ๋์์ ๋๊ธฐ์ธ ๊ฒ์ด๋ค.
// Runnable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ํด๋์ค ์ ์
class MyTask implements Runnable {
@Override
public void run() {
// ๋น๋๊ธฐ๋ก ์คํํ ์์
System.out.println("Hello from a thread!");
}
}
public class Main {
public static void main(String[] args) {
// Thread ๊ฐ์ฒด ์์ฑ
Thread thread = new Thread(new MyTask());
// ์ค๋ ๋ ์คํ
thread.start();
// Non-Blocking์ด๋ฏ๋ก ๋ค๋ฅธ ์์
๊ณ์ ๊ฐ๋ฅ
System.out.println("Main thread is running...");
// Sync๋ฅผ ์ํด ์ค๋ ๋์ ์์
์๋ฃ ์ฌ๋ถ ํ์ธ
while (thread.isAlive()) {
System.out.println("Waiting for the thread to finish...");
}
System.out.println("Thread finished!");
System.out.println("Run the next tasks");
}
}Main thread is running...
Waiting for the thread to finish...
Waiting for the thread to finish...
Waiting for the thread to finish...
Waiting for the thread to finish...
...(์๋ต)
Hello from a thread!
Waiting for the thread to finish...
Thread finished!
Run the next tasks๋น๋๊ธฐ-๋ธ๋กํน(Async Blocking)
Async Blocking์กฐํฉ์ ๋ค๋ฅธ ์์ ์ด ์งํ๋๋ ๋์ ์์ ์ ์์ ์ ๋ฉ์ถ๊ณ ๊ธฐ๋ค๋ฆฌ๋(Blocking), ๋ค๋ฅธ ์์ ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ๋ก ์ฒ๋ฆฌํ์ง ์์ ์์๋๋ก ์์ ์ ์ํํ์ง ์๋ (Async) ๋ฐฉ์์ด๋ค.๋น๋๊ธฐ-๋ธ๋กํน์ ๊ฒฝ์ฐ ๋๊ธฐ-๋ธ๋กํน๊ณผ ๋น๊ตํด์ ์ฑ๋ฅ ์ฐจ์ด๊ฐ ๊ฑฐ์ ์๊ธฐ ๋๋ฌธ์ ์ค๋ฌด์์ ๋ค๋ฃฐ ์ผ์ ๊ฑฐ์ ์๋ค.

A ํจ์๋ B ํจ์์ ๋ฆฌํด ๊ฐ์ ์ ๊ฒฝ์ฐ์ง ์๊ณ , ์ฝ๋ฐฑ ํจ์๋ฅผ ๋ณด๋ธ๋ค.(๋น๋๊ธฐ)
๊ทธ๋ฐ๋ฐ B ํจ์์ ์์ ์ ๊ด์ฌ์์์๋ ๋ถ๊ตฌํ๊ณ , A ํจ์๋ B ํจ์์๊ฒ ์ ์ด๊ถ์ ๋๊ธด๋ค.(๋ธ๋กํน)
๋ฐ๋ผ์ A ํจ์๋ ์์ ๊ณผ ๊ด๋ จ ์๋ B ํจ์์ ์์ ์ด ๋๋ ๋๊น์ง ๊ธฐ๋ค๋ ค์ผ ํ๋ค.
๋น๋๊ธฐ-๋
ผ๋ธ๋กํน(Async Non-Blocking)
Async Non-Blocking์กฐํฉ์ ๋ค๋ฅธ ์์ ์ด ์งํ๋๋ ๋์์๋ ์์ ์ ์์ ์ ์ฒ๋ฆฌํ๊ณ (Non-Blocking), ๋ค๋ฅธ ์์ ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ๋ก ์ฒ๋ฆฌํ์ง ์์ ์์ ์์๊ฐ ์ง์ผ์ง์ง ์๋ (Async) ๋ฐฉ์์ด๋ค.๋ค๋ฅธ ์์ ์ ๊ฒฐ๊ณผ๊ฐ ์์ ์ ์์ ์ ์ํฅ์ ์ฃผ์ง ์๋ ๊ฒฝ์ฐ์ ํ์ฉํ ์ ์๋ค.

A ํจ์๋ B ํจ์๋ฅผ ํธ์ถํ๋ค.
์ด ๋ ์ ์ด๊ถ์ B ํจ์์ ์ฃผ์ง ์๊ณ , ์์ ์ด ๊ณ์ ๊ฐ์ง๊ณ ์๋๋ค.(๋ ผ๋ธ๋กํน)
๋ฐ๋ผ์ B ํจ์๋ฅผ ํธ์ถํ ์ดํ์๋ ๋ฉ์ถ์ง ์๊ณ ์์ ์ ์ฝ๋๋ฅผ ๊ณ์ ์คํํ๋ค. ๊ทธ๋ฆฌ๊ณ B ํจ์๋ฅผ ํธ์ถํ ๋ ์ฝ๋ฐฑ ํจ์๋ฅผ ํจ๊ป ์ค๋ค.
B ํจ์๋ ์์ ์ ์์ ์ด ๋๋๋ฉด A ํจ์๊ฐ ์ค ์ฝ๋ฐฑ ํจ์๋ฅผ ์คํํ๋ค.(๋น๋๊ธฐ)
Async Non-Blocking ์กฐํฉ์ ์์
๋์ด ๋ง๊ฑฐ๋ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ์์
์ ์ฒ๋ฆฌํด์ผ ํ๋ ๊ฒฝ์ฐ์ ์ ํฉํ๋ค. ๋์ฉ๋ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ฑฐ๋ ๋ง์ ์์ฒญ์ ์ฒ๋ฆฌํ๋ ์๋น์ค์์๋ ๋น๋๊ธฐ ๋
ผ๋ธ๋กํน ๋ฐฉ์์ ์ฌ์ฉํ์ฌ ํ ์์
์ด ์ฒ๋ฆฌ๋๋ ๋์ ๋ค๋ฅธ ์์
์ ์ฒ๋ฆฌํ ์ ์์ผ๋ฏ๋ก ์ ์ฒด ์ฒ๋ฆฌ ์๊ฐ์ ์ค์ผ ์ ์์ด ์ ํ๋ฆฌ์ผ์ด์
์ฒ๋ฆฌ ์ฑ๋ฅ์ ํฅ์ ์ํฌ ์ ์๊ฒ ๋๋ค.
์ฐธ๊ณ
Last updated