Javascript๋ฅผ ๋ธ๋ผ์ฐ์ ๋ฐ์์๋ ์คํํ ์ ์๋๋ก ํ๋ Javascript์ ๋ฐํ์
node.js๋ฅผ ์ ํ๋ค๋ณด๋ฉด ์์ฃผ ๋์ค๋ ๋ง์ ๋ค์๊ณผ ๊ฐ๋ค
- ์ด๋ฒคํธ ๊ธฐ๋ฐ
- ์ฑ๊ธ ์ฐ๋ ๋ ๋ ผ๋ธ๋กํน ๋ชจ๋ธ
1. ์ด๋ฒคํธ ๊ธฐ๋ฐ
node.js๋ ์ด๋ฒคํธ ๋ฆฌ์ค๋์ ๋ฑ๋กํด๋ ์ฝ๋ฐฑํจ์๋ฅผ ์คํํ๋ ๋ฐฉ์์ผ๋ก ๋์ํ๋ค.
router.get("/", (req, res, next) => {
})์ด๋ฌํ ์ด๋ฒคํธ ๊ธฐ๋ฐ ๋ชจ๋ธ์์๋ ์ด๋ฒคํธ์ ๋ฐ๋ผ ํธ์ถ๋๋ ์ฝ๋ฐฑํจ์๋ฅผ ๊ด๋ฆฌํ๋ ๊ฒ์ด โ์ด๋ฒคํธ ๋ฃจํโ์ด๋ค. (๋ธ๋ผ์ฐ์ ์ ์ด๋ฒคํธ ๋ฃจํ์๋ ๋ค๋ฆ)
์ด๋ฒคํธ ๋ฃจํ ๋์ ์๋ฆฌ
node.js๊ฐ ์์๋๋ฉด ์ค๋ ๋๊ฐ ์๊ธฐ๊ณ , ์ด๋ฒคํธ ๋ฃจํ๊ฐ ์์ฑ๋๋ค. ์ด๋ฒคํธ ๋ฃจํ๋ 6๊ฐ์ ํ์ด์ง๋ฅผ ๋ผ์ด๋ ๋ก๋น์ผ๋ก ์ํํ๋ฉฐ ๋์ํ๋ค.
๊ฐ ๋จ๊ณ๋ FIFO ํ๋ฅผ ๊ฐ์ง๋ฉฐ ๋ค์๊ณผ ๊ฐ์ ์์ ์ ์ํํ๋ค.
- timers
setTimeout,setInterval๊ฐ์ timer ํจ์๋ฅผ ์ฒ๋ฆฌํ๋ค- ํ์ด์ฆ๋ฅผ ์ํํ๋ฉด์ ์ฒ๋ฆฌํ ์ ์๋ timer ํจ์๋ฅผ ํ์ธํ๊ณ ์ฝ๋ฐฑํจ์๋ฅผ ์คํํ๋ค.
- pending callbacks
- ๋ค์ ๋ฃจํ ๋ฐ๋ณต์ผ๋ก ์ฐ๊ธฐ๋ I/O ์๋ฃ ๊ฒฐ๊ณผ๊ฐ ํ์ ๋ด๊ธด๋ค.
- I/O ์์ ์ด ์๋ฃ๋๋ฉด ๋ค์ ๋ฃจํ์์ ์ด ๋จ๊ณ ํ์ ๋ค์ด์ ์๊ณ , I/O ์์ ๋ธ๋ก ๋ด์ ์ฝ๋ฐฑํจ์๋ค์ poll ๋จ๊ณ์ ํ๋ก ๋๊ฒจ์ค๋ค.
- ๋ํ TCP ์ค๋ฅ ๊ฐ์ ์์คํ ์์ ์ ์ฝ๋ฐฑ์ ์คํํ๋ค.
- idle, prepare : ๋ด๋ถ์ฉ์ผ๋ก๋ง ์ฌ์ฉ๋จ
- poll
- I/O์ ์ฐ๊ด๋ ์ฝ๋ฐฑ์ ์คํํ๋ฉฐ timer ๋จ๊ณ์์์ ์คํ์๊ฐ ์ ์ด๋ฅผ ๋ด๋นํ๋ค.
setTimeout,setInterval,setImmediate๋ก ๋ฑ๋กํ ์ฝ๋ฐฑ ์ ์ธ ๋๋ถ๋ถ์ด ์ฌ๊ธฐ์ ์ฒ๋ฆฌ๋จ.- poll ํ์ ์์ธ ์ฝ๋ฐฑํจ์๋ค์ ํ๋๊ฐ ๋์ง ์์๋๊น์ง ๋ชจ๋ ๋๊ธฐ์ ์ผ๋ก ์คํํ๋ค.
- ํ๋๊ฐ ๋๊ฑฐ๋ ๋์ด์ ์คํํญ ์ฝ๋ฐฑํจ์๊ฐ ์์ ๊ฒฝ์ฐ ์๋ ๊ท์น์ ๋ฐ๋ผ ๋์ํ๋ค.
- check ๋จ๊ณ๋ฅผ ๊ฒ์ฌํ์ฌ
setImmediate๊ฐ ์๋์ง ํ์ธํ๋ค. ์์ผ๋ฉด check ๋จ๊ณ๋ก ๋์ด๊ฐ๋ค - timer ๋จ๊ณ๋ฅผ ๊ฒ์ฌํ์ฌ ์คํํ timer ํจ์๊ฐ ์๋์ง ํ์ธํ๋ค. ์์ผ๋ฉด ์์๋๊น์ง ๋๊ธฐ ํํ timer ๋จ๊ณ๋ก ๋์ด๊ฐ๋ค.
- timer ๋จ๊ณ๋ฅผ ๋๊ธฐํ๋ ๋์ poll ํ์ ์ฝ๋ฐฑํจ์๊ฐ ์์ด๋ฉด ์ฆ์ ์คํํ๋ค
- check ๋จ๊ณ๋ฅผ ๊ฒ์ฌํ์ฌ
- check
setImmediate์ ์ฝ๋ฐฑํจ์๋ฅผ ์คํํ๋ค.
- close callbacks
- close, destroy ์ด๋ฒคํธ์ ๋ฐ๋ฅธ ์ฝ๋ฐฑํจ์๋ฅผ ์คํํ๋ค ex)
socket.on("close", ...)
์์)
setTimeout(() => {
console.log('timeout');
}, 0);
setImmediate(() => {
console.log('immediate');
});- ์ด ์ฝ๋๋ฅผ ์คํ์ timer ๋จ๊ณ๋ผ๋ฉด
setTimeout์ ๋จผ์ ์คํํจ. timer ๋จ๊ณ๋ฅผ ์ง๋ฌ๋ค๋ฉดsetImmediate๋ฅผ ๋จผ์ ์คํํ๋ค
const fs = require('fs');
fs.readFile(__filename, () => {
setTimeout(() => {
console.log('timeout');
}, 0);
setImmediate(() => {
console.log('immediate');
});
});- i/o ์ฝ๋ฐฑ ํจ์๋ poll ๋จ๊ณ์์ ์คํ๋๊ธฐ์ ํญ์
setImmediate๋จผ์ ์ํ๋๊ฒ ๋๋ค.
2. ์ฑ๊ธ ์ฐ๋ ๋ ๋ ผ๋ธ๋กํน ๋ชจ๋ธ
Node.js๋ฅผ ์ ํ๋ค๋ณด๋ฉด ์์ฃผ ๋ณด์ด๋ ๋ง์ด Node.js๋ ์ฑ๊ธ ์ฐ๋ ๋ ๋ ผ๋ธ๋กํน์ด๋ผ๋ ๋ง์ด๋ค.
๋จผ์ ์ฑ๊ธ์ฐ๋ ๋์ ๋ํด์ ์ดํด๋ณด๋ฉด, Node.js๋ ์ด๋ก ์ ์ผ๋ก๋ ์ฑ๊ธ ์ฐ๋ ๋์ง๋ง ์์ ํ ์ฑ๊ธ ์ฐ๋ ๋๋ ์๋๋ค.
๊ตฌ์ฒด์ ์ผ๋ก๋ node.js๋ ๋๊ธฐ ์์ ์ด ๋์ํ๋ main thread(์ด๋ฒคํธ๋ฃจํ)์ libuv ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ๊ด๋ฆฌ๋๋ ์ค๋ ๋ํ์์ ๋ธ๋กํน ์์ ์ด ์ํ๋๋ค. ๋คํธ์ํฌ I/O ๋ฑ ๋น๋๊ธฐ ์์ ์ด ๋ฐ์ํด๋ main thread๋ฅผ ๋ง์ง ์๊ณ , ๋น๋๊ธฐ ์์ ์ ๋ฐฑ๊ทธ๋ผ์ด๋์์ ์ฒ๋ฆฌํ๊ณ main thread ๋ ๊ทธ๋์ ๋ค๋ฅธ ์์ ์ ์ํํ ์ ์๋ค. ์ด๊ฒ์ด ์ฑ๊ธ์ค๋ ๋ ๋ ผ๋ธ๋กํน์ ์๋ฏธ์ด๋ค.
- ๋๊ธฐ ์์ : main thread ์์ ์คํ (์ด๊ฒ๋ libuv์์ ๊ด๋ฆฌ๋๊ธด ํจ)
- ๋น๋๊ธฐ ์์ (I/O, ๋คํธ์ํฌ ์์ ) : libuv๋ฅผ ํตํด ๋ฐฑ๊ทธ๋ผ์ด๋์์ ์ฒ๋ฆฌ๋จ.
์๋ฅผ๋ค์ด, ๊ฐ๊ฐ 3์ด, 5์ด, 6์ด, 8์ด๊ฐ ๊ฑธ๋ฆฌ๋ ์์ฒญ์ด ๋งค์ฐ ์งง์ ๊ฐ๊ฒฉ์ผ๋ก ๋ค์ด์จ๋ค๋ฉด ์๋์ ๊ฐ์ด ๋์ํ๋ค
- ์ ๋ถ ๋๊ธฐ์์ ๋ง ์์๊ฒฝ์ฐ, event loop์์ ์ฐจ๋ก๋๋ก ์ฒ๋ฆฌ๋์ด ์ด 3 + 5 + 6 + 8 = 22์ด + a ๊ฑธ๋ฆผ. (a๋ context switching)
- ์ ๋ถ ๋น๋๊ธฐ์์ ๋ง ์์๊ฒฝ์ฐ, libuv์์ ๋น๋๊ธฐ๋ก ๋์ํ๊ธฐ์ ๊ฐ์ฅ ์ค๋ ๊ฑธ๋ฆฌ๋ ์์ ๊ณผ ๊ฐ์ 8์ด๊ฐ ๊ฑธ๋ฆผ.
libuv
libuv๋ ๋น๋๊ธฐ ์์ ์ ์ฒ๋ฆฌํด์ฃผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ด๋ค. fs, socket๊ณผ ๊ฐ์ด libuv๋ฅผ ํธ์ถํ๋ ํจ์๊ฐ ์์ผ๋ฉด libuv๋ ์ฝ๋ ์ ์ด๊ถ์ ๊ฐ์ง์ง ์๊ณ ๋ค์ ์ฝ๋๋ฅผ ์คํํ ์ ์๋๋ก ์ ์ด๊ถ์ ๋๊ธด๋ค (๋ ผ๋ธ๋กํน)
libuv๋ ์์ ์ ์ค๋ ๋ํ์ ๊ฐ์ง๊ณ ์๋ค. ๋ฐ๋ผ์ ํธ์ถ๋ ์์ ์ ๊ฒ์ฌํ ๋คํธ์ํฌ I/O์ OS ์ปค๋์์ ์ง์ํด์ฃผ๋ ์์ ์ด๋ฉด ์ปค๋์ ์ฌ์ฉํ๊ณ , ์ปค๋์ด ์ง์ํ์ง ์๋ ์์ (Disk I/O ๋ฑ)์ ๋ํด์๋ง ์์ ์ ์ค๋ ๋ํ์ ์ฌ์ฉํ๋ค. ์ด๊ฒ์ด ์์ ํ ์ฑ๊ธ์ฐ๋ ๋๊ฐ ์๋๋ค๋ผ๋ ๊ฒ์ ์๋ฏธ์ด๋ค.
libuv์ ์ค๋ ๋ํ์ ์ฌ์ฉํ๋ ์์ ๋ค
- DNS resolver (because most OS provide only synchronous API for this)
- File system API (because this is messy to do asynchronously cross-platform)
- Crypto (Because this uses the CPU)
- Zlib (zip compression)
๋ฐ๋ผ์ libuv์ ์ค๋ ๋ ํ์ ๋๋ฆด ์๋ ์์ผ๋ libuv์ ์ค๋ ๋ํ์ ์ฌ์ฉํ๋ ์์ ์ด ์๋ ๊ฒ์ ๋ํด์๋ ํฐ ์๋ฏธ๊ฐ ์๋ค. (Disk I/O ๋ํ Disk๊ฐ ํ๋์ด๋ฉด ํ๋ฒ์ ํ๋์ฉ ์ ๊ทผ ๊ฐ๋ฅํ๊ธฐ์ ์๋ฏธ ์์) (๊ธฐ๋ณธ์ 4๊ฐ)
worker_threads
node.js ์์ ์๋์ ์ผ๋ก ๋ฉํฐ์ค๋ ๋๋ฅผ ์ฌ์ฉํ ์ ์๋ ๋ฐฉ๋ฒ
3. ํด๋ฌ์คํฐ ๋ชจ๋ (๋ฉํฐ ์ฝ์ด ์ฌ์ฉ)
๋ฌผ๋ฆฌ ์ฝ์ด๋ ๋์ผ ์์ ์ ํ๋์ ์ค๋ ๋๋ง ์คํํ๋ค. ์ด๋ ํ๋์ node.js ์ธ์คํด์ค๋ ํ๋์ ์ค๋ ๋๋ฅผ ์ฌ์ฉํจ์ผ๋ก ์๋ฌด๋ฆฌ ๋ง์ด ์ฌ์ฉํด๋ดค์ ์ฑ๊ธ ์ฝ์ด ํ๋๋ง ์ฐจ์งํ๋ค. (libuv ์ค๋ ๋ํ์์ ์ฌ๋ฌ ์ค๋ ๋๋ฅผ ๋ ์ฌ์ฉํ ์ ์์ง๋ง, ์ผ๋ฐ์ ์ผ๋ก ํ๋์ ์ฝ์ด๋ง ์ฌ์ฉํ๋ค๊ณ ๋ด)
์ต์ CPU๋ ๋ฉํฐ์ฝ์ด๊ฐ ๊ธฐ๋ณธ์ด๋ฏ๋ก ๋ฉํฐ์ฝ์ด CPU์์ ํ๋์ node.js๋ง ๋์ฐ๋ฉด ๋นํจ์จ์ ์ด๋ค. ๋ฐ๋ผ์ ๋ค์๊ณผ ๊ฐ์ด ๋ฉํฐ ์ฝ์ด๋ฅผ ์ ๋ถ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ์ ์๋ค.
- node.js cluster ๋ชจ๋ ์ฌ์ฉ
- PM2 ์ฌ์ฉ
- worker threads ์ฌ์ฉ : node.js 10.5+ ๋ฒ์ ๋ถํฐ CPU ์ง์ฝ ์์ ์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ ์ ์๋๋ก ํจ. ํ๋ก์ธ์ค๋ ํ๋๋ก ๋์ํจ.
ํ์ง๋ง ์ด๋ฌํ ์ต์ ํ ๊ธฐ๋ฒ์ด ํญ์ ํตํ๋ ๊ฒ์ด ์๋๋ค. ๋ง์ฝ ์ฑ๋ฅ bottleneck์ด javascript ์ฝ๋ ์์ฒด์ ์๋ค๋ฉด ํด๋ฌ์คํฐ๊ฐ ๋์์ด ๋๋ค. ํ์ง๋ง ๋ง์ฝ network i/o๋ db ์์ ์ ์๋ค๋ฉด ํฐ ๋์์ด ์๋๋ค. ๋ฐ๋ผ์ ์ด๋๊ฐ ๋ฌธ์ ์ธ์ง๋ฅผ ์ฐพ์์ผํ๋ค.
For example if you are CPU limited in your nodejs process with the running of your own Javascript, then perhaps you want to implement nodejs clustering to get multiple CPUs all running different requests. But, if the real bottleneck is in your database, then cluster your nodejs request handlers wonโt help with the database bottleneck.
Benchmark, measure, come up with theories based on the data for what to change, design specific tests to measure that, then implement one of the theories and measure. Adjust based on what you measure. You can only really do this properly (without wasting a lot of time in unproductive directions) by measuring first, making appropriate adjustments and then measuring progress.
์ฐธ๊ณ
- https://velog.io/@tennfin1/NodeJS%EA%B0%80-Spring%EB%B3%B4%EB%8B%A4-%EB%B9%A0%EB%A5%B4%EB%8B%A4%EA%B3%A0-%EC%89%BD%EA%B2%8C-%EC%84%A4%EB%AA%85%ED%95%B4%EB%93%9C%EB%A6%BC\
- https://jdm.kr/blog/166
- https://medium.com/@vdongbin/node-js-%EB%8F%99%EC%9E%91%EC%9B%90%EB%A6%AC-single-thread-event-driven-non-blocking-i-o-event-loop-ce97e58a8e21
- https://stackoverflow.com/questions/63369876/nodejs-what-is-maximum-thread-that-can-run-same-time-as-thread-pool-size-is-fo