Java (3) ์ธ๋ค์ผํ ๋ฆฌ์คํธํ ์ ๋ด CompletableFuture ๋ Console ์ ๋ก๊ทธ๊ฐ ์๋๊ฐ? ForkJoinPool ์ ๋ฐ๋ชฌ ์ค๋ ๋๋ฅผ ์์๋ณด์ CompletableFuture๋ฅผ ํ์ฉํ ๋น๋๊ธฐ์์ ์ฝ์์ ๋ก๊ทธ๊ฐ ๋จ์ง ์๋ ๋ฌธ์ ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ฅผ ์ํด CompletableFuture ์ฌ์ฉ๋ฒ์ ์ตํ๋ ์ค, ๋น๋๊ธฐ ์ฒ๋ฆฌ ๋ก์ง(Task ํด๋์ค์ doAsyncWithForkJoinPool( ))์์ ์ฝ์์ ๋ก๊ทธ๊ฐ ๋จ์ง ์๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ต๋๋ค. ์ด์ ๋ํด ์์๋ณด๊ณ ์ ํฉ๋๋ค. ๋ฌธ์ ๊ฐ ๋์๋ ์ฝ๋๋ก ์คํ ๊ฒฐ๊ณผ๋ "๋ฉ์ธ ์ข ๋ฃ" ๋ง ๋์ฌ ๋ฟ, Thread.currentThread().getName() ๊ด๋ จ ๋ก๊ทธ๋ ์ฝ์์ ๋์ค์ง ์์์ต๋๋ค.// Main ํด๋์คpublic static void main(String[] args) { Task task = new Task(); CompletableFuture future = task.doAsyncWit.. Java์ ๋๊ธฐํ ๊ธฐ๋ฒ - synchronized & ReentrantLock ์ ๋ํด ๋ค์๊ณผ ๊ฐ์ ์์ผ๋ก ๊ธ์ด ์ด์ด์ง๋๋ค.synchronized ์๊ฐsynchronized vs static synchronized synchronized ๋จ์ ์ ๊ทน๋ณตํ ReentrantLock ์๊ฐsynchronized vs ReentrantLock 1. synchronized ์๊ฐ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์๋ ์ฌ๋ฌ ์ค๋ ๋๊ฐ ๋์์ ๊ฐ์ ์์์ ์ ๊ทผํ ๊ฒฝ์ฐ, ์์์น ๋ชปํ ๋ฌธ์ (๋ฐ์ดํฐ ์์, ์ถฉ๋ ๋ฑ)๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค. ์ด๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด ๋๊ธฐํ(synchronization) ๊ธฐ๋ฒ์ด ํ์ํฉ๋๋ค.Java์์ ์ ๊ณตํ๋ synchronized ํค์๋๋ ๋ชจ๋ํฐ ๋ฝ(Monitor Lock)์ ์ด์ฉํด ๋๊ธฐํ๋ฅผ ์ง์ํฉ๋๋ค. ๋ชจ๋ํฐ๋ OS๊ฐ ์๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ์์ค์์ ์ ๊ณตํ๋ ๋๊ธฐํ ๋ฉ์ปค๋์ฆ์ ๋๋ค. Java์ ๋ชจ๋ ๊ฐ์ฒด(์ธ.. ํต์ฌ ๊ธฐ๋ฅ์ ๋จผ์ ๊ตฌํํ๊ธฐ ์ํ ๊ณ ๋ฏผ๊ณผ ๋ ธ๋ ฅ ์ฐํ ์ฝ ํ๋ฆฌ์ฝ์ค๊ฐ ๋๋๊ณ , ํต์ฌ ๊ธฐ๋ฅ ๋ถํฐ ๊ตฌํํ๊ธฐ ์ํด '์ซ์ ์ผ๊ตฌ ๊ฒ์' ๋ฏธ์ ์ ๋ค์ ํ์ด๋ณด์๋ค. ํ์ง๋ง, ํต์ฌ ๊ธฐ๋ฅ๋ถํฐ ๊ตฌํ ํ๊ธฐ ์ํด, ๊ณ ๋ฏผํ๊ณ ๋ต์ ์ฐพ๋ ๊ณผ์ ์ด 2์ฃผ๊ฐ ๊ฑธ๋ ธ๋ค.์ด ๊ณผ์ ์์ ์๊ฒผ๋ ๊ถ๊ธ์ฆ๋ค์ Q&A ํ์์ผ๋ก ๋จผ์ ์๊ธฐํด๋ณด๊ฒ ๋ค! *์์๋ก ๋์ค๋ ์ฝ๋์ ์ ๋ฌธ์ ๋๋ค.โ ์๊ตฌ์ฌํญ์ ๋ง์กฑํ๊ธฐ ์ํด ๊ฒ์ฆ(validate)์ ์ด๋์ ํ ๊ฒ์ธ๊ฐ?์๊ตฌ์ฌํญ์ ๋ง์กฑํ๋ ์กฐ๊ฑด๋ค์ ์ด๋์ ๊ฒ์ฆํด์ผ ํ ๊น? ๋์ ์๊ฐ์ ๊ฐ ๊ฐ์ฒด์ ์์ฑ์์์ ๊ฒ์ฆ์ ํ๋ ๊ฒ์ด๋ค.์ด ๋, ๊ฐ์ฒด๊ฐ ์์ฑ์ด ๋๋ค๋ฉด ๊ทธ ๊ฐ์ฒด๋ ์๊ตฌ์ฌํญ์ ์กฐ๊ฑด์ ์ถฉ์กฑํ๋ ๋ณด์ฅ๋ ๊ฐ์ฒด์์ ๋ปํ๊ธฐ ๋๋ฌธ์ด๋ค. ์๋ฅผ ๋ค์ด, ์ซ์ ์ผ๊ตฌ ๊ฒ์์ "์๋ก ๋ค๋ฅธ ์ธ ์๋ฆฌ์" ๋ผ๋ ์๊ตฌ์ฌํญ์ ๋ค์๊ณผ ๊ฐ์ ์กฐ๊ฑด๋ค์ ๋ดํฌํ๊ณ ์๋ค.โ ์๋ก ๋ค๋ฅธ ์ธ ์๋ฆฌ์์ ์ซ์๋ ์ค๋ณต๋์ง .. ์ด์ 1 ๋ค์