
๊ธฐ์ ๋ฉด์ ๋จ๊ณจ ์ง๋ฌธ โ๋์์ฑ๊ณผ ๋ณ๋ ฌ์ฑโ ๊ฐํธ ์ ๋ฆฌ
๊ธฐ์ ๋ฉด์ ๋จ๊ณจ ์ง๋ฌธ โ๋์์ฑ๊ณผ ๋ณ๋ ฌ์ฑโ ๊ฐํธ ์ ๋ฆฌ ๊ด๋ จ
๋์์ฑ(Concurrency)๊ณผ ๋ณ๋ ฌ์ฑ(Parallelism)์ ๋๊ท๋ชจ ํธ๋ํฝ๊ณผ ๋ฐฉ๋ํ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ํ๊ฒฝ์์๋ ๊ผญ ์์๋์ด์ผ ํ๋ ํต์ฌ ๊ฐ๋ ์ ๋๋ค. ์น ์๋น์ค๋ถํฐ ๋จธ์ ๋ฌ๋, ๋น ๋ฐ์ดํฐ ๋ถ์๊น์ง, ๋ง์ ๊ธฐ์ ๋ค์ด ์ด ๋ ๊ฐ์ง ๊ธฐ๋ฒ์ ์ ์ ํ ์กฐํฉํ์ฌ ๋์ ์ฑ๋ฅ๊ณผ ํ์ฅ์ฑ์ ์ป๊ณ ์์ต๋๋ค. ์ด ๋๋ฌธ์ ๊ธฐ์ ๋ฉด์ ์์๋ ๋์์ฑ๊ณผ ๋ณ๋ ฌ์ฑ์ ๊ฐ๋ ์ ์ฐจ์ด, ๊ทธ๋ฆฌ๊ณ ์ค์ ์ฌ๋ก๋ ์ ์ฉ ๋ฐฉ์์ ๊ดํด ๋ฌป๋ ์ง๋ฌธ์ด ์์ฃผ ๋์ค๋๋ฐ์. ์ด๋ฒ ๊ธ์ ํตํด ๋ฏธ๋ฆฌ ๊ฐ๋ ์ ์ดํดํด ๋์๋ฉด ๋์์ด ๋ ๊ฑฐ๋ผ ์๊ฐํฉ๋๋ค.

๋์์ฑ(Concurrency) ๊ฐ๋ ์ ๋ฆฌ
๋์์ฑ์ด๋, ์ค์ ๋ก๋ ํ๋์ CPU Core๋ง ์ฌ์ฉํ๋๋ผ๋ ๋งค์ฐ ๋น ๋ฅธ ์์ ์ ํ(Context Switching)์ ํตํด ์ฌ๋ฌ ์์ ์ด ๊ฒน์ณ ์คํ๋๋ ๊ฒ์ฒ๋ผ ๋ณด์ด๋๋ก ๋ง๋๋ ์ํํธ์จ์ด์ ๊ธฐ๋ฒ์ ๋๋ค. CPU๋ ํ ์์ ์ ํ ๊ฐ์ง ์์ ๋ง ์ฒ๋ฆฌํ ์ ์์ง๋ง, ์ ํ ์๋๊ฐ ์๋ ๋น ๋ฅด๋ค ๋ณด๋ ์ฌ๋ฌ ํ๋ก์ธ์ค๋ ์ค๋ ๋๊ฐ ๋์์ ๋์ํ๋ ๊ฒ์ฒ๋ผ ๋๋ ์ ์์ต๋๋ค.
์ด ๋ฐฉ์์ I/O ์์ ์ด ๋น๋ฒํ ์ผ์ด๋๋ ํ๊ฒฝ์์ ํนํ ํจ๊ณผ์ ์ ๋๋ค. ํ์ผ ์์คํ , ๋คํธ์ํฌ, ์ฌ์ฉ์ ์ ๋ ฅ ๊ฐ์ ๋๊ธฐ ์๊ฐ์ด ๊ธด ์์ ์ด ์งํ๋๋ ๋์ CPU๊ฐ ๋ค๋ฅธ ์ผ์ ํ ์ ์์ผ๋ฏ๋ก ์ ์ฒด ์์คํ ์๋ต ์๋๊ฐ ๋นจ๋ผ์ง๋๋ค.
Threading
์ด์์ฒด์ ๊ฐ ์ ๊ณตํ๋ ์ค๋ ๋(Thread)๋ฅผ ์ด์ฉํ๋ฉด, ํ ํ๋ก์ธ์ค ์์ ์ฌ๋ฌ ์คํ ํ๋ฆ์ ๋ง๋ค ์ ์์ต๋๋ค. ์ค๋ ๋๋ ๋ ๋ฆฝ์ ์ธ ํ๋ฆ์ ๊ฐ์ง๋ง, ์ฌ์ค์ ํ๋์ CPU์์ ๋ฒ๊ฐ์ ์คํ๋๊ธฐ ๋๋ฌธ์ ๋ง์น ๋์ ์ฒ๋ฆฌ๋๋ ๋ฏํ ํจ๊ณผ๊ฐ ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๊ฒ์์ ๊ฐ๋ฐํ ๋ ๊ทธ๋ํฝ ๋ ๋๋ง ํ๋ฆ๊ณผ ์ฌ์ฉ์ ์ ๋ ฅ ํ๋ฆ์ ๋ถ๋ฆฌํ๋ฉด, ์ข ๋ ์์ฐ์ค๋ฝ๊ณ ํจ์จ์ ์ธ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
๋ค๋ง ์ค๋ ๋๊ฐ ๋ง์์ง๋ฉด ์๋ก๊ฐ ๊ฐ์ ์์์ ์ด์ฉํ ๋ ์ถฉ๋์ด ์ผ์ด๋ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๊ฐ ์ค๋ ๋๊ฐ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋์์ ์์ ํ๋ฉด ๊ฒฐ๊ณผ๊ฐ ๋ค์ํฌ ์ ์์ผ๋ฉฐ, ์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์๋ ๋ฐ์ดํฐ ์ ๊ทผ ์์๋ฅผ ์ ์ ํ๊ฑฐ๋ ๊ฐ๋จํ ๋๊ธฐํ ๊ธฐ๋ฒ์ ์ ์ฉํด์ผ ํฉ๋๋ค.
๋๋ฌด ๊น์ ์์ค์ผ๋ก ๋ค์ด๊ฐ๋ฉด Lock, Mutex, Deadlock ๊ฐ์ ๊ฐ๋ ์ด ์ด์ด์ง์ง๋ง, ํฐ ํ๋ฆ์์ ๋ณด๋ฉด โํ๋์ ์์์ ๋์์ ์ ๊ทผํ๋ฉด ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์๊ณ , ์ด๊ฑธ ๋ง์ผ๋ ค๋ฉด ์กฐ์จ์ด ํ์ํ๋คโ ์ ๋๋ก ์ดํดํด๋ ์ถฉ๋ถํฉ๋๋ค.
Async I/O
๋น๋๊ธฐ I/O๋ ๋คํธ์ํฌ๋ ๋์คํฌ ์ ๊ทผ์ฒ๋ผ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ์์ ์ ๋ฏธ๋ฆฌ ์์ฒญํด ๋ ๋ค, ๊ทธ ๋๊ธฐ ์๊ฐ์ CPU๊ฐ ๋ค๋ฅธ ์ผ์ ์ฒ๋ฆฌํ๋๋ก ํ๋ ๋ฐฉ์์ ๋๋ค. Node.js, Python์ asyncio, JavaScript์ async/await ๋ฑ์ด ๋ํ์ ์ธ ์์์ด๋ฉฐ, ํ๊บผ๋ฒ์ ๋ง์ ์์ฒญ์ด ๋ค์ด์ค๋ ์๋ฒ ํ๊ฒฝ์์ ํ์ํ ์ฑ๋ฅ์ ๋ฐํํฉ๋๋ค. ์ฑ๊ธ ์ค๋ ๋๋๋ผ๋ ๋น๋๊ธฐ I/O๋ฅผ ํตํด ๋์์ฑ์ ๋์ผ ์ ์๊ธฐ ๋๋ฌธ์, ๊ท๋ชจ๊ฐ ํฐ ์์คํ ์์ ์์ฃผ ์ค์ํ ๊ธฐ์ ๋ก ๊ผฝํ๋๋ค.
๋ณ๋ ฌ์ฑ(Parallelism) ๊ฐ๋ ์ ๋ฆฌ
๋ณ๋ ฌ์ฑ์ ์ค์ ๋ก ์ฌ๋ฌ ๊ฐ์ CPU ์ฝ์ด๋ ์ฌ๋ฌ ๋์ ์๋ฒ์์ ๋์์ ์ฐ์ฐ์ ์ํํ๋ ๊ธฐ๋ฒ์ ๋๋ค. ๋ฌผ๋ฆฌ์ ์ผ๋ก ์ฝ์ด๊ฐ ์ฌ๋ฌ ๊ฐ๊ฑฐ๋ ์๋ฒ๊ฐ ์ฌ๋ฌ ๋๋ผ๋ฉด, ๊ฐ ์ฝ์ด๋ ์๋ฒ๊ฐ ์๋ก ๋ค๋ฅธ ์์ ์ ๋งก์ ๋ณ๋ ฌ๋ก ๊ณ์ฐํ๋ฉด ๋๋ฏ๋ก ์ฒ๋ฆฌ ์๋๊ฐ ํฌ๊ฒ ํฅ์๋ฉ๋๋ค. ํนํ ์ฐ์ฐ๋์ด ํด์๋ก ๋ณ๋ ฌ์ฑ์ ํจ๊ณผ๊ฐ ๋์ฑ ๋๋๋ฌ์ง๋๋ค.
Multi-Processing
๋ฉํฐํ๋ก์ธ์ฑ(Multi-Processing)์ ํ๋์ ์ปดํจํฐ ์์์ ์ฌ๋ฌ ํ๋ก์ธ์ค๋ฅผ ๋์์ ์คํํด ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ์คํํ๋ ๋ฐฉ์์ ๋๋ค. ํ๋ก์ธ์ค๋ง๋ค ๋ ๋ฆฝ๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ๊ธฐ ๋๋ฌธ์, ๊ณต์ ์์ ๊ด๋ฆฌ๊ฐ ์๋์ ์ผ๋ก ๋จ์ํ๋ค๋ ์ด์ ์ด ์์ง๋ง, ํ๋ก์ธ์ค ๊ฐ ํต์ ์๋ ์ถ๊ฐ ๋น์ฉ์ด ๋ญ๋๋ค. ๋ฉํฐ์ฝ์ด CPU ํ๊ฒฝ์ด๋ฉด ์ด์์ฒด์ ๊ฐ ์ฌ๋ฌ ํ๋ก์ธ์ค๋ฅผ ์ฝ์ด๋ณ๋ก ๋ฐฐ์นํด ์ค์ ๋ณ๋ ฌ ์ฐ์ฐ์ ์ํํ๊ฒ๋ ํด์ค๋๋ค.
๋ถ์ฐ ์์คํ
๋ถ์ฐ ์์คํ ์ ์ฌ๋ฌ ๋์ ๋ฌผ๋ฆฌ ์๋ฒ(๋ ธ๋)๋ฅผ ๋คํธ์ํฌ๋ก ์ฐ๊ฒฐํด ์์ ์ ๋๋ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๋ ์ํคํ ์ฒ์ ๋๋ค. ์์ปจ๋, Hadoop์ด๋ Spark ๊ฐ์ ํ๋ ์์ํฌ๋ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ๋ ธ๋์ ๋ถ์ฐ ์ ์ฅํ๊ณ ๋์์ ๊ณ์ฐํ ๋ค ๊ฒฐ๊ณผ๋ฅผ ํฉ์นจ์ผ๋ก์จ ๋๋์ ๋ฐ์ดํฐ๋ฅผ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํฉ๋๋ค. ๋ ธ๋๋ฅผ ๋๋ฆฌ๋ฉด(Scale-Out) ์ฒ๋ฆฌ ๋ฅ๋ ฅ๋ ๊ฐ์ด ๋์ด๋์ง๋ง, ๋ ธ๋ ๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ๊ณผ์ ์ด ๋ง์์ง์๋ก ์ค๋ฒํค๋๊ฐ ์ปค์ง ์ ์์ต๋๋ค.

๋ณ๋ ฌ์ฑ์ CPU ์ฝ์ด๊ฐ ๋ง์์๋ก(๋๋ ๋ ธ๋ ์๊ฐ ๋ง์์๋ก) ์ ์ฒด ๊ณ์ฐ ์๋๋ฅผ ๋น์ฝ์ ์ผ๋ก ๋์ด์ฌ๋ฆด ์ ์๋ค๋ ์ฅ์ ์ด ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋จธ์ ๋ฌ๋์ ๋๊ท๋ชจ ํ๋ ฌ ์ฐ์ฐ์ด๋ ๊ทธ๋ํฝ ๋ ๋๋ง์ฒ๋ผ ์ฐ์ฐ๋์ด ํฐ ์์ ์ ์ฌ๋ฌ ์ฝ์ด๋ก ๋ถ์ฐํด ์ฒ๋ฆฌํ๋ฉด, ๋จ์ผ ์ฝ์ด๋ง ์ฌ์ฉํ ๋๋ณด๋ค ํจ์ฌ ์งง์ ์๊ฐ์ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ต๋๋ค.
๊ทธ๋ฌ๋ ํ๋์จ์ด ์์์ด ์ถฉ๋ถํด์ผ ํ๊ณ , ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ์ํ ์ฝ๋ ์์ ์ด๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ ์ฌ์ค๊ณ๊ฐ ํ์ํ ๋๊ฐ ๋ง์ต๋๋ค. ํ๋ก์ธ์ค๋ ๋ ธ๋ ๊ฐ ํต์ ์ค๋ฒํค๋, ๋ฐ์ดํฐ ๋ถํ ยทํตํฉ ๊ณผ์ , ๋๊ธฐํ ๋ฌธ์ ๋ฑ ์ถ๊ฐ๋ก ๊ณ ๋ คํ ์ ์ด ๋์ด๋ฉ๋๋ค.
๋์์ฑ๊ณผ ๋ณ๋ ฌ์ฑ์ ์ฐจ์ด์
- ๋์์ฑ(Concurrency): ๋จ์ผ CPU ํ๊ฒฝ์์๋ ๋น ๋ฅธ ์ ํ(Context Switching)์ ํตํด ์ฌ๋ฌ ์์ ์ด ๋์์ ์งํ๋๋ ๊ฒ์ฒ๋ผ ๋ณด์ด๊ฒ ํ๋ ๊ธฐ๋ฒ์ ๋๋ค. CPU๊ฐ ํ์๊ฐ์๋ ํ๋์ ์์ ๋ง ์ฒ๋ฆฌํ์ง๋ง, ์ ํ ์๋๊ฐ ๋งค์ฐ ๋น ๋ฅด๋ฏ๋ก ์ฌ๋ฌ ์์ ์ด ๊ฒน์ณ ์คํ๋๋ ๋ฏํ ํจ๊ณผ๋ฅผ ๋ ๋๋ค.
- ๋ณ๋ ฌ์ฑ(Parallelism): ์ฌ๋ฌ ๊ฐ์ CPU Core ๋๋ ์ฌ๋ฌ ๋์ ์๋ฒ(๋ ธ๋)์์ ์ค์ ๋ก ์ฌ๋ฌ ์์ ์ด ๋ฌผ๋ฆฌ์ ์ผ๋ก ๋์์ ์ฒ๋ฆฌ๋๋ ๊ธฐ๋ฒ์ ๋๋ค. ๋์์ฑ์ ์ฃผ๋ก ์ํํธ์จ์ด์ ์ธ ๋ฐฉ์์ผ๋ก ์ฐฉ์ ํจ๊ณผ๋ฅผ ๋ด์ง๋ง, ๋ณ๋ ฌ์ฑ์ ์ค์ ํ๋์จ์ด ์์์ด ์ฌ๋ฌ ๊ฐ ์์ด์ผ ์๋ฏธ๊ฐ ์ปค์ง๋๋ค.
์ด๋ ๊ฒ ๊ตฌ๋ถํ๊ธด ํด๋ ์ค์ ์ ๋ฌด ํ๊ฒฝ์์๋ ๋์์ฑ๊ณผ ๋ณ๋ ฌ์ฑ์ ํจ๊ป ์ฐ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์๋ฐ์. ์๋ฅผ ๋ค์ด, ์ฑ๊ธ ์ฝ์ด์์๋ ๋์์ฑ ๊ธฐ๋ฒ์ผ๋ก I/O ๋๊ธฐ ์๊ฐ์ ์ต์ํํ๋ฉด์ ๋ฉํฐ์ฝ์ด๋ ์ฌ๋ฌ ์๋ฒ๋ฅผ ํ์ฉํด ๋ณ๋ ฌ์ฑ๊น์ง ํ๋ณดํ๋ฉด, ์ ์ฒด ์ฒ๋ฆฌ๋(Throughput)๊ณผ ์๋ต์ฑ(Response Time)์ ๋ชจ๋ ๋์ผ ์ ์์ต๋๋ค.
๋์/๋ณ๋ ฌ ์ฒ๋ฆฌ ์์ ์ดํด๋ณด๊ธฐ
์น ์๋ฒ์ ๋น๋๊ธฐ ์ฒ๋ฆฌ
์น ์๋ฒ์ ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ ๋๊ท๋ชจ ํธ๋ํฝ์ ๋์์ ์ฒ๋ฆฌํด์ผ ํ๋ ์ํฉ์์ ํนํ ์ค์ํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ๋ง์ ์ฌ์ฉ์๊ฐ ํ๊บผ๋ฒ์ ์ ์ํ๋ฉด, ๋คํธ์ํฌ I/O(๋ฐ์ดํฐ๋ฒ ์ด์ค ์กฐํ, ์ธ๋ถ API ์์ฒญ ๋ฑ) ๋๊ธฐ ์๊ฐ์ด ์์ฃผ ๋ฐ์ํ์ฃ . ๋น๋๊ธฐ I/O(Async I/O)๋ Thread๋ฅผ ํ์ฉํด ๋์์ฑ(Concurrency)์ ๋์ด๋ฉด, ํ ์์ฒญ์ด ๋๊ธฐ ์ํ์ ์์ ๋๋ ๋ค๋ฅธ ์์ฒญ์ ์ฒ๋ฆฌํ ์ ์์ด, ์ ์ฒด ์์คํ ์๋ต ์๋๊ฐ ๋นจ๋ผ์ง๋๋ค.
๋ฉํฐ์ฝ์ด ์๋ฒ ํ๊ฒฝ์ด๋ผ๋ฉด, ์์ปค ํ๋ก์ธ์ค๋ ๋ฉํฐ์ค๋ ๋๋ฅผ ์ฌ๋ฌ ๊ฐ ๋์ด ๋ณ๋ ฌ์ฑ(Parallelism)๊น์ง ํ๋ณดํ์ฌ, ์ค์ CPU ์ฝ์ด๊ฐ ๋์์ ์ฌ๋ฌ ์์ ์ ๋ถ๋ดํ๊ฒ ํจ์ผ๋ก์จ ์ฒ๋ฆฌ๋(Throughput)์ ๊ทน๋ํํ ์ ์์ต๋๋ค. ์ด๋ฌํ ๋ฐฉ์์ Nginx, Node.js, Java ๊ธฐ๋ฐ Netty๋ Tomcat ๊ฐ์ ์๋ฒ์์ ๋๋ฆฌ ์ฐ์ด๋ฉฐ, ๋๊ธฐ ์๊ฐ์ ์ต์ํํจ๊ณผ ๋์์ CPU๋ฅผ ์ต๋ํ ํ์ฉํ๊ธฐ ์ํด ํ์์ ์ธ ํจํด์ผ๋ก ์๋ฆฌ ์ก์์ต๋๋ค.
๋จธ์ ๋ฌ๋๊ณผ ๋ณ๋ ฌ ์ฐ์ฐ
๋จธ์ ๋ฌ๋๊ณผ ๋ณ๋ ฌ ์ฐ์ฐ์ ๋๊ท๋ชจ ์ฐ์ฐ๋์ ๋จ์ถํ๊ธฐ ์ํด ํ์์ ์ผ๋ก ๊ณ ๋ ค๋ฉ๋๋ค. ๋จธ์ ๋ฌ๋ ๋ถ์ผ์์๋ ๋๊ท๋ชจ ๋ฐ์ดํฐ์ ์ ๋ํ ์ฐ์ฐ(ํ๋ ฌ ๊ณฑ์ , ๋ฒกํฐ ์ฐ์ฐ ๋ฑ)์ด ๋ฐ๋ณต์ ์ผ๋ก ๋ฐ์ํ๋ฏ๋ก, ๋จ์ผ ์ฝ์ด์์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ฉด ํ์ต ์๊ฐ์ด ๊ธฐํ๊ธ์์ ์ผ๋ก ๋์ด๋ ์ ์๋๋ฐ์.
์ด๋ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ฌ๋ฌ CPU ์ฝ์ด ํน์ GPU ์ฝ์ด๊ฐ ๋์์ ๊ณ์ฐ์ ์ํํ๋ ๋ณ๋ ฌ์ฑ(Parallelism)์ ์ ๊ทน ํ์ฉํฉ๋๋ค. ์๋ฅผ ๋ค์ด, TensorFlow๋ PyTorch ๊ฐ์ ํ๋ ์์ํฌ๋ GPU ๊ฐ์์ ํตํด ์์ฒ~์๋ง ๊ฐ์ ์ฝ์ด๊ฐ ๋ณ๋ ฌ๋ก ์ฐ์ฐํจ์ผ๋ก์จ ๋ชจ๋ธ ํ์ต ์๊ฐ์ ํฌ๊ฒ ์ค์ ๋๋ค.
๋ํ ๋ฐ์ดํฐ ์ ์ถ๋ ฅ, ๋ก๊น , ์ค๊ฐ ๊ฒฐ๊ณผ ์๊ฐํ ๋ฑ์ ๋์์ฑ(Concurrency) ๊ธฐ๋ฒ์ ์ ์ฉํด, ๋น๋๊ธฐ๋ก ์ฒ๋ฆฌํ๋ฉด ์ ์ฒด ํ์ดํ๋ผ์ธ ํจ์จ์ด ๋์์ ธ, ๋ณ๋ ฌ ์ฐ์ฐ ์ฑ๋ฅ๊น์ง ๋์ฑ ํจ๊ณผ์ ์ผ๋ก ํ์ฉํ ์ ์์ต๋๋ค.
Microservices ์ํคํ ์ฒ
Microservices ์ํคํ ์ฒ๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฌ๋ฌ ์์ ์๋น์ค๋ก ๋๋์ด, ๊ฐ๊ฐ ๋ ๋ฆฝ์ ์ธ Process๋ก ๋์ํ๊ฒ ํ๋ ๊ตฌ์กฐ์ ๋๋ค. ์ด๋ ํน์ ์๋น์ค์ ํธ๋ํฝ์ด ๋ชฐ๋ฆฌ๋ฉด ๊ทธ ์๋น์ค๋ง Scale-Out(ํ๋ก์ธ์ค๋ ์ปจํ ์ด๋ ์ ์ฆ๊ฐ)ํ์ฌ ์ฝ๊ฒ ํ์ฅํ ์ ์์ต๋๋ค. ๋ํ ๋ฉํฐ์ฝ์ด ์๋ฒ๋ ์ฌ๋ฌ ์๋ฒ ๋ ธ๋๋ฅผ ํ์ฉํ๋ฉด, ๋ณ๋ ฌ์ฑ(Parallelism)์ ํ๋ณดํ์ฌ ์ค์ ๋ก ์ฌ๋ฌ ์ฝ์ด์์ ์๋น์ค๋ฅผ ๋์์ ๊ตฌ๋ํ ์ ์์ฃ .
์๋น์ค ๋ด๋ถ์์๋ Thread Pool, ๋น๋๊ธฐ I/O ๋ฑ์ ์ฌ์ฉํด I/O ๋๊ธฐ๋ฅผ ์ต์ํํ๋ ๋์์ฑ(Concurrency) ๊ธฐ๋ฒ์ ์ ์ฉํจ์ผ๋ก์จ, CPU๊ฐ ํ ์ผ์ด ์๋๋ก ๋ฐฉ์น๋์ง ์๊ฒ ํ๋๋ฐ์. ์ด๋ฌํ ์กฐํฉ์ผ๋ก ์ธํด ๋๊ท๋ชจ ํธ๋ํฝ ์ํฉ์์๋ ํน์ ๊ธฐ๋ฅ(์๋ฅผ ๋ค์ด ๊ฒฐ์ , ์ธ์ฆ, ๊ฒ์ ๋ฑ)์ด ๋ณ๋ชฉ ์ง์ ์ด ๋์ง ์๋๋ก ์ ์ฐํ๊ฒ ํ์ฅํ ์ ์๊ณ , ์๋ต์ฑ(Response Time)๋ ์์ ์ ์ผ๋ก ์ ์งํฉ๋๋ค.
Real-time Data Streaming
Real-time Data Streaming ํ๊ฒฝ์ ์ค์๊ฐ์ผ๋ก ์์์ง๋ ๋ฐ์ดํฐ๋ฅผ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํด ์๋ฏธ ์๋ ๊ฒฐ๊ณผ๋ฅผ ์ป๊ณ ์ ํ ๋ ์ ์ฉํฉ๋๋ค. Kafka, Spark Streaming, Flink ๋ฑ์ ๋ฉ์์ง ํ ๊ตฌ์กฐ์ ๋ถ์ฐ ์ฒ๋ฆฌ๋ฅผ ๊ฒฐํฉํด, ๊ฑฐ๋ํ ๋ฐ์ดํฐ ์คํธ๋ฆผ์ ์ฌ๋ฌ Topic์ด๋ Partition์ผ๋ก ๋๋์ด ๋ณ๋ ฌ์ฑ(Parallelism)์ ๊ทน๋ํํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ์ด๋ฒคํธ๊ฐ ๋ค์ด์ค๋ฉด ์ฌ๋ฌ ํ๋ก์ธ์ค ํน์ ์ค๋ ๋๊ฐ ๋์์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ ๋ถ์ํ๊ณ , ๊ฒฐ๊ณผ๋ฅผ ํฉ์ณ ์ฆ์ ๋์๋ณด๋์ ๋ฐ์ํ๊ฑฐ๋ ์ด์ ์งํ๋ฅผ ์๋ฆผ์ผ๋ก ๋ฐ์กํ ์ ์๋๋ฐ์. ๋ ธ๋ ๋ด๋ถ์ ์ผ๋ก๋ Thread๋ ๋น๋๊ธฐ I/O๋ฅผ ์ฌ์ฉํด ๋์์ฑ(Concurrency)์ ํ๋ณดํฉ๋๋ค. ์ด๋ I/O ๋๊ธฐ ์๊ฐ์ ์ค์ด๊ณ , ํด๋ฌ์คํฐ ์ ์ฒด์ ์ผ๋ก๋ ๋ ธ๋๋ฅผ ๋๋ ค ์ค์ ๋ณ๋ ฌ ์ฐ์ฐ์ ์ํํ๋ฏ๋ก, ์์ญ๋ง~์๋ฐฑ๋ง ๊ฑด ์ด์์ ์ด๋ฒคํธ๋ ๋น ๋ฅธ ์ง์ฐ(Latency) ์์ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
์ด๋ฅผ ํตํด ๊ธ์ต๊ถ์ ์ค์๊ฐ ๊ฑฐ๋ ๋ชจ๋ํฐ๋ง, IoT ์ผ์ ๋ฐ์ดํฐ ๋ถ์, ๊ฐ์ข ๋ก๊ทธ ์ค์๊ฐ ๋ถ์ ๋ฑ์ด ๊ฐ๋ฅํ ๊ฒ์ด์ฃ .

์ ๋ฆฌํ๋ฉฐ
๊ฒฐ๋ก ์ ์ผ๋ก ๋์์ฑ(Concurrency)๊ณผ ๋ณ๋ ฌ์ฑ(Parallelism)์ ๊ฐ๊ฐ ๋ชฉ์ ๊ณผ ํ์ฉ ๋ฒ์๊ฐ ๋ค๋ฅด์ง๋ง, ํ๋์ ๋๊ท๋ชจ ์์คํ ์์๋ ๋์ ํจ๊ป ์ ์ฉํด์ผ ์ต์ ์ ์ฑ๋ฅ์ ์ป์ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, ์น ์๋ฒ์ฒ๋ผ I/O๊ฐ ๋น๋ฒํ ๋ฐ์ํ๋ ์๋น์ค์์๋ ๋น๋๊ธฐ I/O๋ฅผ ํตํด ๋์์ฑ์ ํ๋ณดํ๊ณ , ๋์์ ๋ฉํฐ์ฝ์ด ์์์ ๋ณ๋ ฌ๋ก ํ์ฉํด ๋๊ท๋ชจ ํธ๋ํฝ์ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค. ๋จธ์ ๋ฌ๋์ด๋ ๋น ๋ฐ์ดํฐ ๋ถ์์ฒ๋ผ ๊ณ์ฐ๋์ด ์์ฒญ๋ ๋ถ์ผ์์๋ ๋ชจ๋ธ ํ์ต์ด๋ ๋๊ท๋ชจ ์ฐ์ฐ์ ๋ณ๋ ฌ์ฑ์ ํตํด ์ฒ๋ฆฌ ์๊ฐ์ ์ค์ด๊ณ , ์ฃผ๋ณ ์์ (I/O, ๋ก๊น , ๋ฐ์ดํฐ ๊ด๋ฆฌ ๋ฑ)์ ๋์์ฑ ๊ธฐ๋ฒ์ผ๋ก ํจ์จํํจ์ผ๋ก์จ ์ ์ฒด ํ์ดํ๋ผ์ธ ์ฑ๋ฅ์ ๊ทน๋ํํ๋ ์์ ๋๋ค.
์ด๋ฒ ๊ธ์ ํตํด ๋์์ฑ๊ณผ ๋ณ๋ ฌ์ฑ์ ๊ฐ๋ ์ ๋ํด ์ ํํ ํ์ ํ๋ ๊ณ๊ธฐ๊ฐ ๋์๊ธธ ๋ฐ๋๋๋ค. ๋ค์ ๊ธ์์๋ ๊ธฐ์ ๋ฉด์ ์์ ์์ฃผ ๋ฑ์ฅํ๋ โ์คํ ์คํค๋งโ์ โ์ค๋ ธ์ฐํ๋ ์ดํฌ ์คํค๋งโ์ ๋ํด ์ดํด๋ณด๊ฒ ์ต๋๋ค.