2023. 1. 21. 21:58ใJAVA/Effective JAVA
item07. ๋ค ์ด ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ํด์ ํ๋ผ.
" p39. ๋ฐฑ๊ทธ๋ผ์ด๋ ์ฐ๋ ๋, ScheduledThreadPoolExecutor"
Executor๋ฅผ ์๊ธฐ์ ์ Thread, Runnable์ด ๋ญ์ง๋ถํฐ ์์์ผ Executor๋ฅผ ์ดํดํ ์ ์๊ธฐ ๋๋ฌธ์
๋จผ์ Thread์ Runnable์ด ๋ฌด์์ธ์ง๋ถํฐ ์ฐพ์๋ดค๋ค.
์ฐ์ ์ฐ๋ ๋๋ ํ๋ก๊ทธ๋จ ์คํ์ ๊ฐ์ฅ ์์ ๋จ์๋ก, ์ผ๋ฐ์ ์ผ๋ก ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ง๋ค์ด ์คํํ๋ฉด 1๊ฐ์ ๋ฉ์ธ ์ค๋ ๋์ ์ํด ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ค.
๊ทธ๋ฐ๋ฐ 1๊ฐ์ ์ค๋ ๋ ๊ฐ์ง๊ณ ๋ ๋์์ ์ฌ๋ฌ ์์ ์ ์ํํ ์๊ฐ ์๋ค. ๋ฐ๋ผ์ ๋์์ ์ฌ๋ฌ ์์ ์ ์ํํ๊ธฐ ์ํด์๋ ๋ณ๋์ ์ค๋ ๋๋ฅผ ๋ง๋ค์ด์ ์คํํด์ผ ํ๋ค.
์๋ฐ์์๋ ๋ฉํฐ ์ค๋ ๋ ๊ธฐ๋ฐ์ผ๋ก ๋์์ฑ ํ๋ก๊ทธ๋๋ฐ์ ์ง์ํ๊ธฐ ์ํด์ Runnable, Thread, Callable, Executor, Future, ExecutorService, Excutors... ๋ฑ ๋ฐฉ๋ฒ๋ค์ ์ง์ํ๊ณ ์๋ค.
- Thread
: Thread ํด๋์ค๋ ์๋ฐ์์ ๋น๋๊ธฐ ์์ ์ ๋ํ์ ์ผ๋ก ์ฌ์ฉํ๋ ํด๋์ค์ด๋ค.
- Runnable
: Runnable์ 1๊ฐ์ ๋ฉ์๋ ๋ง์ ๊ฐ๋ ํจ์ํ ์ธํฐํ์ด์ค์ด๋ค.
static class Task implements Runnable {
@Override
public void run() {
try {
Thread.sleep(2000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread() + " world");
}
}
Thread thread = new Thread(new Task());
thread.start();
System.out.println(Thread.currentThread() + " hello");
์ด๋ ๊ฒ ๋ณ๋์ ์ค๋ ๋๋ฅผ ๋ง๋ค์ด์ ์์ ํ ๊ฒ์ ํ์ธํ ์ ์๋ค.
- callable
: Runnable๊ณผ ๋น์ทํ๋ฐ Runnable์ ๋ฆฌํด๊ฐ์ด ์์ง๋ง Callalbe์ ๋ฆฌํด๊ฐ๋ ์ค ์ ์๋ค.
๋ฐ๋ผ์ ๋ฆฌํด๊ฐ์ ์ ๊ณตํด์ผ ํ๋ ๋น๋๊ธฐ ์์ ์ด๋ผ๋ฉด Callable์ ์ฌ์ฉํ๋ฉด ๋๋ค.
static class CallableTask implements Callable<String> {
@Override
public String call() throws Exception {
Thread.sleep(2000L);
return Thread.currentThread() + " world";
}
}
- ThreadPool
๋ง์ฝ ์ค๋ ๋๋ฅผ 100๊ฐ๋ฅผ ๋ง๋ค์ด์ ์ฌ์ฉํ๋ค๊ณ ๊ทธ๋๋ง๋ค ์๋ก ์์ฑํด์ ์คํํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๋ ๋๋ฉฐ, ๊ต์ฅํ ๋นํจ์จ์ ์ด๋ค.
๋ฐ๋ผ์ ์๋ฐ์์๋ ์ฐ๋ ๋๋ฅผ ๋ฏธ๋ฆฌ ๋ง๋ค์ด๋๊ณ ์ฌ์ฌ์ฉํ๊ธฐ ์ํด์ ThreadPool์ด๋๊ฒ์ ์ ๊ณตํด ์ฐ๋ ๋๋ฅผ ๊ด๋ฆฌํ ์ ์๋๋ก ํ๋ค.
Executor ์ธํฐํ์ด์ค๊ฐ ์ฐ๋ ๋ ํ์ ๊ตฌํํ๊ธฐ ์ํ ์ธํฐํ์ด์ค์ด๋ค.
๊ทธ๋ฆฌ๊ณ ExecutorService๊ฐ ์์ (Runnable, Callalbe) ๋ฑ๋ก์ ์ํ ์ธํฐํ์ด์ค๋ก Executor๋ฅผ ์์๋ฐ์์ ์์ ๋ฑ๋ก ๋ฟ๋ง ์๋๋ผ ์คํ์ ์ํ ์ฑ ์๋ ๊ฐ๋๋ค.
๋ฐ๋ผ์ ์ฐ๋ ๋ ํ์ ๊ธฐ๋ณธ์ ์ผ๋ก ExecutorServie์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ค.
์ง์ ์ฐ๋ ๋๋ฅผ ๋ค๋ฃจ๋ ๊ฒ์ด ๋ฒ๊ฑฐ๋กญ๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ๋์์ฃผ๋ ํฉํ ๋ฆฌ ํด๋์ค๋ก Executors๋ฅผ ์ ๊ณตํ๋ค.
Executors ํด๋์ค๋ฅผ ํตํด ์ฐ๋ ๋ ํ์ ์์ฑํ๊ณ ๋ค์ํ ๋ฐฉ์์ผ๋ก Thread๋ฅผ ๊ด๋ฆฌํ ์ ์๋ค.
newFixedThreadPool
: ์ฃผ์ด์ง ์ค๋ ๋ ๊ฐ์๋งํผ ์์ฑํ๊ณ , ๊ทธ ์๋ฅผ ์ ์งํ๋ค.
ExecutorService service = Executors.newFixedThreadPool(10);
newFixedThreadPool์ ์ฌ์ฉํ๋ฉด ์ต๋ 10๊ฐ๋ง ๋ง๋ค ์ ์๊ฒ ํ๊ณ , ๋๋จธ์ง ์์ ์ ํ ๋๋ ์ค๋ ๋๋ฅผ ์ฌ์ฌ์ฉํ๊ฒ ๋ค๋ ๋ป์ด๋ค.
๋ฐ๋ผ์ ์๋ก์ด ์์ ์ด ์ถ๊ฐ๋๋๋ผ๋ ์ค๋ ๋๋ 10๊ฐ ์ด์ ์์ฑ๋์ง ์๊ณ ๋๋จธ์ง๋ ์ฌ์ฌ์ฉ ๋๊ธฐ ๋๋ฌธ์ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น์ ๋ํ ๋ถ๋ด์์ด ์๋ก์ด ์์ ์ ์ถ๊ฐํ ์ ์๋ค.
newCachedThreadPool
: ์ฒ๋ฆฌํ ์์ ์ ์ค๋ ๋๊ฐ ๋ง์์ง๋ฉด ๊ทธ ๋งํผ ์ค๋ ๋๋ฅผ ์ฆ๊ฐํ์ฌ ์์ฑํ๋ค. ์ด๋ ์ค๋ ๋ ์์ฑ์ ์ ํ์ ๋์ง ์๊ธฐ ๋๋ฌธ์ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๋ก ์ด์ด์ง ๊ฐ๋ฅ์ฑ๋ ์๊ธฐ ๋๋ฌธ์ ์กฐ์ฌํด์ ์ฌ์ฉํด์ผ ํ๋ค.
ExecutorService service1 = Executors.newCachedThreadPool();
newSingleThreadExecutor
: ์ค๋ ๋๋ฅผ ๋จ ํ๋๋ง ์์ฑํ๋ ๊ฒ์ด๋ค. (๋นํจ์จ์ )
ExecutorService service2 = Executors.newSingleThreadExecutor();
newScheduledThreadPool
: ํน์ ์๊ฐ ์ดํ์ ์คํ๋๊ฑฐ๋ ์ฃผ๊ธฐ์ ์ผ๋ก ์์ ์ ์คํํ ์ ์๋ค.
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
๊ทธ๋ฆฌ๊ณ ๋ง์ฝ cpu์ ๋ฏผ๊ฐํ๋ค๋ฉด
int numberOfCpu = Runtime.getRuntime().availableProcessors();
์ด๋ฐ์์ผ๋ก cpu์ ๊ฐ์์ ๋ง์ถฐ์ ์ค๋ ๋ ๊ฐ์๋ฅผ ํ ๋นํ ์๋ ์๋ค.
for (int i = 0; i < 100; i++) {
service.submit(new Task());
}
์์ ์ Callable, Runnable ์ ํํ๋ก ์ถ๊ฐ ๊ฐ๋ฅํ๊ณ , submit ํจ์๋ก ์ถ๊ฐํ๋ค.
Future<String> submit = service.submit(new CallableTask());
System.out.println(submit.get());
๊ทธ๋ฆฌ๊ณ ์ด๋ Callable์ ๋ฆฌํด ๊ฐ์ Future๋ก ๋ฐ๊ฒ ๋๊ณ , get์ ํตํด์ ๊ฒฐ๊ณผ ๊ฐ์ ์ป์ด์ฌ ์ ์๋ค.
'JAVA > Effective JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ดํํฐ๋ธ ์๋ฐ] Item08 ์๋ฒฝ๊ณต๋ต (0) | 2023.01.25 |
---|---|
[์ดํํฐ๋ธ ์๋ฐ] Item8. finalizer์ cleaner ์ฌ์ฉ์ ํผํ๋ผ. (0) | 2023.01.22 |
[์ดํํฐ๋ธ ์๋ฐ] Item07 ์๋ฒฝ๊ณต๋ต. WeakHashMap (0) | 2023.01.21 |
[์ดํํฐ๋ธ ์๋ฐ] Item07 ์๋ฒฝ๊ณต๋ต.NullPointerException (0) | 2023.01.21 |
[์ดํํฐ๋ธ ์๋ฐ] Item7. ๋ค ์ด ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ํด์ ํ๋ผ. (1) | 2023.01.21 |