Thread ์คํ
โข
Thread ๋ฅผ extends ํ๋ค.
โข
Runnable ์ implements ํ๋ค.
โข
๋ ๋ค run() ์ override ํ๊ณ Thread ๊ฐ์ฒด์ start() ๋ฅผ ํธ์ถํด์ผ ํ๋ค.
โข
start() ์ join() ์ ์ฐจ์ด๋ ๋ฌด์์ผ๊น?
Thread Pool
โข
in a large-scale application, allocating and deallocating many thread objects creates a significant memory management overhead.
โฆ
๋๊ท๋ชจ ์ดํ๋ฆฌ์ผ์ด์
์์๋ ํ ๋น๊ณผ ์ ๊ฑฐ๊ฐ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ์ค๋ฒํค๋๋ฅผ ์ด๋ํ๋ค.
โข
๋ฏธ๋ฆฌ ์ฐ๋ ๋๋ฅผ ์ผ์ ์๋งํผ ์ค์ ํด ๋๋ ๊ฒ
โข
Executors ์ ExecutorService ๋ก ์ค์ ๊ฐ๋ฅ
โข
Executors.newFixedThreadPool(int nThreads):
โฆ
This type of pool always has a specified number of threads running
โฆ
if a thread is somehow terminated while it is still in use, it is automatically replaced with a new thread.
โฆ
Tasks are submitted to the pool via an internal queue, which holds extra tasks whenever there are more active tasks than threads.
โฆ
์ฅ์ : ์ค๋ฒํค๋๋ฅผ ๋ง์์ค ์ ์๋ค.
โฆ
n๊ฐ ๋งํผ์ ์ฐ๋ ๋๋ฅผ ์์ฑ
โข
Executors.newCachedThreadPool()
โฆ
์ด๊ธฐ ์ฐ๋ ๋ ๊ฐ์๋ 0, ๊ฐ์๋ณด๋ค ๋ง์ ์์ ์์
์ด ์์ฒญ๋๋ฉด ์๋ก์ด ์ฐ๋ ๋๋ฅผ ์์ฑํ์ฌ ์์
์ฒ๋ฆฌ
โฆ
์์
์ด ๋๋ ์ฐ๋ ๋๊ฐ 60์ด ๋์ ์๋ก์ด ์์
์์ฒญ์ด ์์ผ๋ฉด ์ฐ๋ ๋๋ฅผ ์ข
๋ฃํ๊ณ ์ฐ๋ ๋ ํ์์ ์ ๊ฑฐ
start(), join()
submit(), execute()
execute()
โข
์์
์ฒ๋ฆฌ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ์ง ์์ต๋๋ค.
โข
์์
์ฒ๋ฆฌ ๋์ค ์์ธ ๋ฐ์ํ๋ฉด ์ค๋ ๋๊ฐ ์ข
๋ฃ๋๊ณ ํด๋น ์ค๋ ๋๋ ์ค๋ ๋ํ์์ ์ ๊ฑฐํ๊ณ , ์ค๋ ๋ํ์ ์์
์ฒ๋ฆฌ๋ฅผ ์ํด ์๋ก์ด ์ค๋ ๋๋ฅผ ์์ฑํฉ๋๋ค.
submit()
โข
์์
์ฒ๋ฆฌ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํฉ๋๋ค.
โข
์์
์ฒ๋ฆฌ ๋์ค ์์ธ๊ฐ ๋ฐ์ํ๋๋ผ๋ ์ค๋ ๋๋ ์ข
๋ฃ๋์ง ์๊ณ ๋ค์ ์์
์ ์ํดย ์ฌ์ฌ์ฉ๋ฉ๋๋ค.