ํ์ด์ฌ์์ ๋ฉํฐ์ค๋ ๋ฉ์ ์ฌ์ฉํ ์๋ ์์ง๋ง, ํน์ ๊ฒฝ์ฐ์๋ ์ ์ฝ์ฌํญ์ด ์๋ค.
์์ฝํ๋ฉด, ํ์ด์ฌ์ GIL์ ๋ฉํฐ์ค๋ ๋ฉ์ ํตํ ๋ณ๋ ฌํ๋ฅผ ์ ํํ๋ฉฐ, CPU-bound ์์ ์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๋ ค๋ฉด ๋ฉํฐํ๋ก์ธ์ฑ์ด ๋ ์ ํฉํ๋ค. ๋ฉํฐ์ค๋ ๋ฉ์ ์ฃผ๋ก I/O-bound ์์ ๋ฐ ๋์์ฑ์ ๋ค๋ฃฐ ๋ ์ ์ฉํ๋ค.
multiprocessing ๋ชจ๋์์ ์ ๊ณตํ๋ Pool์ ํ์ด์ฌ์์ ๋ฉํฐํ๋ก์ธ์ฑ์ ์ฝ๊ฒ ๊ตฌํํ๊ธฐ ์ํ ๋๊ตฌ์ด๋ค. ๋ฉํฐํ๋ก์ธ์ฑ์ ์ฌ๋ฌ ๊ฐ์ ํ๋ก์ธ์ค๋ฅผ ๋์์ ์คํํ์ฌ ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ๊ฐ๋ฅํ๊ฒ ํ๋ค. Pool์ ํนํ CPU ๋ฐ์ด๋ ์์ (๊ณ์ฐ ์ง์ฝ์ ์ธ ์์ )์ ๊ฐ์ํํ๋ ๋ฐ ์ ์ฉํ๋ค.
Pool ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋, ๋ณ๋ ฌ๋ก ์คํํ๋ ค๋ ํ๋ก์ธ์ค ์๋ฅผ ์ง์ ํ๋ค. ์ผ๋ฐ์ ์ผ๋ก CPU ์ฝ์ด ์๋ ์ํ๋ ๋ณ๋ ฌ์ฑ ์์ค์ ๋ฐ๋ผ ํ๋ก์ธ์ค ์๋ฅผ ์ ํํ๋ฉด ๋๋ค.
from multiprocessing import Pool
# ์ํ๋ ๋ณ๋ ฌ์ฑ ์์ค์ ์ค์
pool = Pool(processes=4) # 4๊ฐ์ ํ๋ก์ธ์ค๋ก ์์
์ ๋ณ๋ ฌ๋ก ์คํ
Pool์ ์์
์ ๋ณ๋ ฌ ํ๋ก์ธ์ค๋ก ๋ถ๋ฐฐํ๊ณ ๊ฐ ํ๋ก์ธ์ค๊ฐ ์์
์ ์ํํ๋ค. pool.map()
๋๋ pool.apply_async()
๋ฅผ ์ฌ์ฉํ์ฌ ์์
์ ํ์ ์ถ๊ฐํ๋ค.
pool.map(function, iterable)
: ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด ๋ด์ ์์๋ฅผ ํจ์์ ๋งคํํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ์์ฐจ์ ์ผ๋ก ๋ฐํํ๋ค.pool.apply_async(function, args)
: ํจ์๋ฅผ ๋น๋๊ธฐ์ ์ผ๋ก ํธ์ถํ๊ณ AsyncResult
๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ค.Pool์ ์์ฑ๋ ํ๋ก์ธ์ค ํ์์ ์์ ์ ๋ณ๋ ฌ๋ก ์คํํ๋ค. ์์ ์ด ์๋ฃ๋๋ฉด ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๊ฑฐ๋ ์ฒ๋ฆฌํ ์ ์๋ค.
results = pool.map(some_function, some_iterable)
๊ฐ ์์ ์ด ์๋ฃ๋๋ฉด ๊ฒฐ๊ณผ๋ฅผ ์ฒ๋ฆฌํ๊ฑฐ๋, ํ์์ ๋ฐ๋ผ ์ ์ฅํ ์ ์๋ค.
for result in results:
process(result)
์์
์ด ์๋ฃ๋๋ฉด pool.close()
๋ฅผ ํธ์ถํ์ฌ ํ์ ๋ซ๊ณ , pool.join()
์ ํธ์ถํ์ฌ ๋ชจ๋ ์์
์ด ์๋ฃ๋ ๋๊น์ง ๋๊ธฐํ๋ค.
pool.close()
pool.join()
Pool์ ์ฌ์ฉํ๋ฉด CPU ๋ฐ์ด๋ ์์ ์ ํจ๊ณผ์ ์ผ๋ก ๋ณ๋ ฌ๋ก ์คํํ๊ณ , ๋ฉํฐ์ฝ์ด ํ๋ก์ธ์์์ ๋์ ์ฑ๋ฅ์ ์ป์ ์ ์๋ค.