We read every piece of feedback, and take your input very seriously.
To see all available qualifiers, see our documentation.
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. Weโll occasionally send you account related emails.
Already on GitHub? Sign in to your account
๐ ์ฃผ์ : Blocking๊ณผ Non-Blocking, ๊ทธ๋ฆฌ๊ณ Async์ Sync์ ์ฐจ์ด์ ์ ์ดํดํ๊ณ ๊ฐ๊ฐ์ ํน์ง๊ณผ ์ฌ๋ก๋ฅผ ํ์ตํฉ๋๋ค.
๐ฏ ์คํฐ๋ ๋ชฉํ
๐ ํต์ฌ ๋ด์ฉ:
์ ์ด๊ถ์ด ๊ด๊ฑด!
์์ ์ ์์ ์ ์งํํ๋ค๊ฐ ๋ค๋ฅธ ์ฃผ์ฒด์ ์์ ์ด ์์๋๋ฉด ๋ค๋ฅธ ์์ ์ด ๋๋ ๋๊น์ง ๊ธฐ๋ค๋ ธ๋ค๊ฐ ์์ ์ ์์ ์ ์์ํ๋ ๊ฒ
๋ค๋ฅธ ์ฃผ์ฒด์ ์์ ์ ๊ด๋ จ์์ด ์์ ์ ์์ ์ ํ๋ ๊ฒ
๊ฒฐ๊ณผ์ ์ฒ๋ฆฌ๊ฐ ๊ด๊ฑด!
Syn์ ๊ทธ๋ฆฌ์ค์ด๋ก 'ํจ๊ป' Chrono๋ '์๊ฐ' ์ด๋ผ๋ ๋ป ํธ์ถํ๋ ํจ์๊ฐ ํธ์ถ๋ ํจ์์ ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ ธ ์์ฐจ๋๋ก ์ฒ๋ฆฌ
ํธ์ถํ๋ ํจ์๊ฐ ํธ์ถ๋ ํจ์์ ์์ ์๋ฃ ์ฌ๋ถ๋ฅผ ์ ๊ฒฝ์ฐ์ง ์๊ณ ์ฒ๋ฆฌ
์์์ ๋ฐฐ์ด 4๊ฐ์ง ๊ฐ๋ ์ ์กฐํฉํด๋ณด์.
Scanner
SocketChannel
Future.get()
CompletableFuture
alert()
fetch().then()
์๋ฐ์ Scanner
import java.util.Scanner; public class BlockingSynchronousExample { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("์ซ์๋ฅผ ์ ๋ ฅํ์ธ์:"); int number = scanner.nextInt(); // ์ ์ด๊ถ์ด ๋์ด๊ฐ๊ณ ์ ๋ ฅ์ด ์๋ฃ๋๊ธฐ ์ ๊น์ง๋ ๋ค์ ์ฝ๋๋ก ๋์ด๊ฐ์ง ์์ (blocking) // ์ ๋ ฅ ํ number ๋ณ์์ ์ ์ฅ๋์ด์ผ ๋ค์์ค๋ก ๋์ด๊ฐ (synch) System.out.println("์ ๋ ฅ๋ ์ซ์: " + number); scanner.close(); } }
SocketChannel์ผ๋ก Non-blocking I/O
import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SocketChannel; public class SynchronousNonBlockingExample { public static void main(String[] args) { try { SocketChannel socketChannel = SocketChannel.open(); socketChannel.configureBlocking(false); // Non-blocking ์ค์ socketChannel.connect(new InetSocketAddress("example.com", 80)); // ์๋ฒ์ ์ฐ๊ฒฐ ์์ฒญ์ ์์ํ๊ณ , ์ ์ด๊ถ์ ํธ์ถ์์ธ ๋ฉ์ธ ์ค๋ ๋๋ก ์ฆ์ ๋ฐํ (Non-blocking) while (!socketChannel.finishConnect()) { // Polling: ์ฐ๊ฒฐ ์ํ๋ฅผ ์ฃผ๊ธฐ์ ์ผ๋ก ํ์ธํ๋ฉฐ ์๋ฃ๋๊ธฐ ์ ๊น์ง ๋๊ธฐ (Synchronous) System.out.println("์ฐ๊ฒฐ ์ค..."); } String request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"; ByteBuffer buffer = ByteBuffer.wrap(request.getBytes()); socketChannel.write(buffer); buffer.clear(); socketChannel.read(buffer); System.out.println("์๋ต: " + new String(buffer.array())); socketChannel.close(); } catch (IOException e) { e.printStackTrace(); } } }
Future.get()์ผ๋ก ๊ฒฐ๊ณผ ๋๊ธฐ ๋น๋๊ธฐ์ ์ผ๋ก ์์ ์ ์คํํ ํ, ๊ฒฐ๊ณผ๋ฅผ ํ์๋ก ํ ๋ ์ฐจ๋จํ๋ฉด์ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์ค๋ ๋ฐฉ์
Blocking์ด ๋ง์์ง๋ฉด ์ค๋ ๋ ํ์ด ๊ณ ๊ฐ๋์ด ์ฑ๋ฅ ์ฅ์ ๋ก ์ด์ด์ง ์ ์๊ธฐ ๋๋ฌธ์ ์ค๋ฌด์์๋ Blocking + Async ์กฐํฉ์ ์ต์ํํ๊ณ ๋์ฒด ๊ธฐ์ ์ ์ฌ์ฉํ๋๊ฒ์ด ๊ถ์ฅ๋จ (CompletableFuture, thenApply() ๋ฑ๋ฑ)
import java.util.concurrent.*; public class BlockingAsynchronousExample { public static void main(String[] args) { ExecutorService executor = Executors.newSingleThreadExecutor(); Future<Integer> future = executor.submit(() -> { // submit ๋ฉ์๋๋ ๊ฒฐ๊ณผ๋ฅผ ๋์ค์ ์ ๊ณต (Asynchr) Thread.sleep(2000); // ์์ ์๋ฎฌ๋ ์ด์ return 42; // ๊ฒฐ๊ณผ ๋ฐํ }); try { System.out.println("๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋ค๋ฆฝ๋๋ค..."); int result = future.get(); // ์ ์ด๊ถ์ด ๋์ด๊ฐ๊ณ , ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ ๋๊น์ง ํธ์ถ์๋ ์ฐจ๋จ๋จ (blocking-sync) System.out.println("๊ฒฐ๊ณผ: " + result); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } finally { executor.shutdown(); } } }
CompletableFuture๋ก ๋น๋๊ธฐ ์ฒ๋ฆฌ
Non-blocking: ์ ์ด๊ถ์ ํธ์ถ์(๋ฉ์ธ ์ค๋ ๋)์๊ฒ ์ฆ์ ๋ฐํ๋๋ฉฐ, ํธ์ถ์๋ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋ค๋ฆฌ์ง ์๊ณ ๋ค๋ฅธ ์์ (์: "๋ค๋ฅธ ์์ ์ํ ์ค..." ์ถ๋ ฅ)์ ๋ฐ๋ก ์ํํ ์ ์๋ค. ๊ฒฐ๊ณผ๋ ๋์ค์ ์ฝ๋ฐฑ(thenAccept)์ ํตํด ์ฒ๋ฆฌ๋๋ค.
Asynchronous: ์์ ์ด ๋ณ๋์ ์ฐ๋ ๋์์ ์คํ๋๋ฉฐ, ํธ์ถ์์ ์์ ์คํ์ด ๋ ๋ฆฝ์ ์ผ๋ก ๋์ํ๋ค. CompletableFuture.supplyAsync()๋ ์๋ก์ด ์ฐ๋ ๋๋ฅผ ์์ฑํ๊ฑฐ๋ ์ฐ๋ ๋ ํ์์ ํ ๋นํด ์์ ์ ๋น๋๊ธฐ์ ์ผ๋ก ์ํํ๋ฉฐ, ๊ฒฐ๊ณผ ์ฒ๋ฆฌ ์ญ์ ๋์ค์ ์ด๋ฃจ์ด์ง๋ค.
import java.util.concurrent.CompletableFuture; public class NonBlockingAsynchronousExample { public static void main(String[] args) { System.out.println("๋น๋๊ธฐ ์์ ์์"); CompletableFuture.supplyAsync(() -> { try { Thread.sleep(2000); // ์์ ์๋ฎฌ๋ ์ด์ } catch (InterruptedException e) { e.printStackTrace(); } return 42; // ๊ฒฐ๊ณผ ๋ฐํ }).thenAccept(result -> System.out.println("๊ฒฐ๊ณผ: " + result)); // ๊ฒฐ๊ณผ๋ฅผ ๋น๋๊ธฐ๋ก ์ฒ๋ฆฌ System.out.println("๋ค๋ฅธ ์์ ์ํ ์ค..."); try { Thread.sleep(3000); // ๋ฉ์ธ ์ค๋ ๋๊ฐ ์ข ๋ฃ๋์ง ์๋๋ก ๋๊ธฐ } catch (InterruptedException e) { e.printStackTrace(); } } }
๐ก ์ฐธ๊ณ ์๋ฃ: [10๋ถ ํ ์ฝํก] ๐ฐ ๋ฉํ ์ Blocking vs Non-Blocking, Sync vs Async ์๋ฒฝํ ์ดํดํ๋ ๋๊ธฐ/๋น๋๊ธฐ & ๋ธ๋กํน/๋ ผ๋ธ๋กํน
The text was updated successfully, but these errors were encountered:
Blocking , Non-blocking ์ ๋ํ ๊ฐ๋ ์ ๋ชฐ๋๋๋ฐ ์ฒ์ ์๊ฒ ๋์๋ค์!
Sorry, something went wrong.
๊ฐ๋ฐ ์ค์ ๋๋ฌด ์์ฐ์ค๋ฝ๊ฒ ์ฌ์ฉํด์ ๋ณ๋ก ์ ๊ฒฝ์ ์์ด ๋ถ๋ถ์ด์๋๋ฐ ์ด๋ก ์ ์ผ๋ก ์ ๋ฆฌํ๊ณ ๋์ด๊ฐ๋ ์ข์ ๊ฑฐ ๊ฐ์ต๋๋ค. Blocking + Async ์กฐํฉ์ ์ต์ํํ๋ ๋ฐฉํฅ์ผ๋ก ๋ ์ ๊ฒฝ ์จ์ ๊ฐ๋ฐ ํด๋ด์ผ๊ฒ ์ต๋๋ค.
๊ฐ๋ฐํ ๋ ๋๊ธฐ, ๋น๋๊ธฐ ๊ฐ๋ ์ ๋ง์ด ์ฌ์ฉํ๊ฑฐ ๊ฐ์๋ฐ non-blocking, blocking์ ํฌ๊ฒ ์ ๊ฒฝ์ฐ์ง ์์๋๊ฑฐ ๊ฐ์์! ๋๋ถ์ 4๊ฐ์ ๊ฐ๋ ์ ๋ํด์๋ ๋ค์ ์์๋ณผ ์ ์๋ ๊ธฐํ์์ต๋๋ค! ๊ฒ๋ค๊ฐ ํ๋ก ํธ์์์ ์์๊น์ง ๋ง์ํด์ฃผ์ ์ ๋ฃ๋๋ฐ ๋ ๋์์ด ๋์๋๊ฑฐ ๊ฐ์ต๋๋ค! ๊ฐ์ฌํฉ๋๋ค!
suna-ji
No branches or pull requests
๐ Blocking VS Non-Blocking, Sync VS Async
๐ ์ฃผ์ :
Blocking๊ณผ Non-Blocking, ๊ทธ๋ฆฌ๊ณ Async์ Sync์ ์ฐจ์ด์ ์ ์ดํดํ๊ณ ๊ฐ๊ฐ์ ํน์ง๊ณผ ์ฌ๋ก๋ฅผ ํ์ตํฉ๋๋ค.
๐ฏ ์คํฐ๋ ๋ชฉํ
๐ ํต์ฌ ๋ด์ฉ:
1. Blocking vs Non-Blocking
Blocking
์์ ์ ์์ ์ ์งํํ๋ค๊ฐ ๋ค๋ฅธ ์ฃผ์ฒด์ ์์ ์ด ์์๋๋ฉด ๋ค๋ฅธ ์์ ์ด ๋๋ ๋๊น์ง ๊ธฐ๋ค๋ ธ๋ค๊ฐ ์์ ์ ์์ ์ ์์ํ๋ ๊ฒ
Non-Blocking
๋ค๋ฅธ ์ฃผ์ฒด์ ์์ ์ ๊ด๋ จ์์ด ์์ ์ ์์ ์ ํ๋ ๊ฒ
2. Synchronous vs Asynchronous
Synchronous
Syn์ ๊ทธ๋ฆฌ์ค์ด๋ก 'ํจ๊ป' Chrono๋ '์๊ฐ' ์ด๋ผ๋ ๋ป
ํธ์ถํ๋ ํจ์๊ฐ ํธ์ถ๋ ํจ์์ ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐ์ ธ ์์ฐจ๋๋ก ์ฒ๋ฆฌ
Asynchronous
ํธ์ถํ๋ ํจ์๊ฐ ํธ์ถ๋ ํจ์์ ์์ ์๋ฃ ์ฌ๋ถ๋ฅผ ์ ๊ฒฝ์ฐ์ง ์๊ณ ์ฒ๋ฆฌ

3. 4๊ฐ์ง ์กฐํฉ
๋ฐฑ์๋: Blocking vs Non-blocking
Scanner
(์ ๋ ฅ ๋๊ธฐ ์ค ํธ์ถ์ ์ฐจ๋จ)SocketChannel
์ผ๋ก Non-blocking I/OFuture.get()
์ผ๋ก ๊ฒฐ๊ณผ ๋๊ธฐCompletableFuture
๋ก ๋น๋๊ธฐ ์ฒ๋ฆฌํ๋ก ํธ์๋: Blocking vs Non-blocking
alert()
(์ฌ์ฉ์ ์ ๋ ฅ ๋๊ธฐ)fetch().then()
+ ๋๊ธฐ ์์ ๋๊ธฐfetch().then()
(๊ฒฐ๊ณผ๋ฅผ ๋น๋๊ธฐ๋ก ์ฒ๋ฆฌ)Blocking + Synchronous
์ ์ด๊ถ์ด Scanner์ ์ ๋ ฅ ์์ ์ผ๋ก ๋์ด๊ฐ๋ฉฐ, ์ ๋ ฅ์ด ์๋ฃ๋ ๋๊น์ง ํธ์ถ์๋ ๋๊ธฐ ์ํ๊ฐ ๋๋ค.
ํธ์ถ์๋ ์ ๋ ฅ์ด ๋๋ ๋๊น์ง ๋ค๋ฅธ ์์ ์ ์ํํ ์ ์๋ค.
์ ๋ ฅ์ด ์๋ฃ๋์ด ๊ฒฐ๊ณผ๊ฐ ๋ณ์์ ์ ์ฅ๋ ์ดํ์๋ง ํธ์ถ์๋ ๋ค์ ์์ ์ผ๋ก ์งํํ ์ ์๋ค.
์์ ์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌ๋๋ฉฐ, ์ ๋ ฅ ์๋ฃ ์ฌ๋ถ๊ฐ ํธ์ถ์์ ํ๋ฆ์ ์ํฅ์ ๋ฏธ์น๋ค.
Non-Blocking + Synchronous
Blocking + Asynchronous
future.get()์ ์์ ์ด ์๋ฃ๋ ๋๊น์ง ํธ์ถ์(๋ฉ์ธ ์ค๋ ๋)๋ฅผ ์ฐจ๋จํฉ๋๋ค.
ํธ์ถ์๋ ๋ค๋ฅธ ์์ ์ ์ํํ์ง ๋ชปํ๊ณ , ๊ฒฐ๊ณผ๊ฐ ๋ฐํ๋ ๋๊น์ง ๊ธฐ๋ค๋ ค์ผ ํฉ๋๋ค.
์์ ์์ฒด๋ ๋น๋๊ธฐ์ ์ผ๋ก ์คํ๋ฉ๋๋ค.
executor.submit()์ ์๋ก์ด ์ฐ๋ ๋์์ ์์ ์ ์คํํ๋ฉฐ, ํธ์ถ์๋ ์์ ์ด ์ฆ์ ์์๋จ์ ๋ณด์ฅ๋ฐ์ง๋ง ๊ฒฐ๊ณผ๋ ๋์ค์ ์ ๊ณต๋ฉ๋๋ค.
์ฆ, ๊ฒฐ๊ณผ ๋๊ธฐ๋ฅผ ์ ์ธํ ์์ ์ฒ๋ฆฌ๋ ๋น๋๊ธฐ์ ์ผ๋ก ์ํ๋ฉ๋๋ค.
Blocking์ด ๋ง์์ง๋ฉด ์ค๋ ๋ ํ์ด ๊ณ ๊ฐ๋์ด ์ฑ๋ฅ ์ฅ์ ๋ก ์ด์ด์ง ์ ์๊ธฐ ๋๋ฌธ์ ์ค๋ฌด์์๋ Blocking + Async ์กฐํฉ์ ์ต์ํํ๊ณ ๋์ฒด ๊ธฐ์ ์ ์ฌ์ฉํ๋๊ฒ์ด ๊ถ์ฅ๋จ (CompletableFuture, thenApply() ๋ฑ๋ฑ)
Non-Blocking + Asynchronous
Non-blocking:
์ ์ด๊ถ์ ํธ์ถ์(๋ฉ์ธ ์ค๋ ๋)์๊ฒ ์ฆ์ ๋ฐํ๋๋ฉฐ, ํธ์ถ์๋ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋ค๋ฆฌ์ง ์๊ณ ๋ค๋ฅธ ์์ (์: "๋ค๋ฅธ ์์ ์ํ ์ค..." ์ถ๋ ฅ)์ ๋ฐ๋ก ์ํํ ์ ์๋ค.
๊ฒฐ๊ณผ๋ ๋์ค์ ์ฝ๋ฐฑ(thenAccept)์ ํตํด ์ฒ๋ฆฌ๋๋ค.
Asynchronous:
์์ ์ด ๋ณ๋์ ์ฐ๋ ๋์์ ์คํ๋๋ฉฐ, ํธ์ถ์์ ์์ ์คํ์ด ๋ ๋ฆฝ์ ์ผ๋ก ๋์ํ๋ค.
CompletableFuture.supplyAsync()๋ ์๋ก์ด ์ฐ๋ ๋๋ฅผ ์์ฑํ๊ฑฐ๋ ์ฐ๋ ๋ ํ์์ ํ ๋นํด ์์ ์ ๋น๋๊ธฐ์ ์ผ๋ก ์ํํ๋ฉฐ, ๊ฒฐ๊ณผ ์ฒ๋ฆฌ ์ญ์ ๋์ค์ ์ด๋ฃจ์ด์ง๋ค.
๐ก ์ฐธ๊ณ ์๋ฃ:
[10๋ถ ํ ์ฝํก] ๐ฐ ๋ฉํ ์ Blocking vs Non-Blocking, Sync vs Async
์๋ฒฝํ ์ดํดํ๋ ๋๊ธฐ/๋น๋๊ธฐ & ๋ธ๋กํน/๋ ผ๋ธ๋กํน
The text was updated successfully, but these errors were encountered: