"Node.js는 싱글 스레드다"라는 말을 많이 듣습니다. 그런데 아무 일도 하지 않는 Node.js 프로그램을 띄우고 리눅스에서 스레드 수를 세어 보면 7개가 나옵니다. 이 차이를 설명하려면 프로세스와 스레드가 정확히 무엇인지부터 알아야 합니다.
'운영체제 기초' 시리즈의 첫 글에서는 프로세스와 스레드를 정의하고, 둘이 메모리를 어떻게 나누고 공유하는지 정리합니다. 그다음 Node.js 프로그램을 직접 띄워 ps, top -H, /proc로 프로세스와 스레드를 세어 보면서 개념을 확인합니다. 실습은 Ubuntu 24.04(커널 6.18), Node.js 22.23, CPU 2개 환경에서 실행했고, 출력은 그때 결과를 그대로 옮겼습니다.
프로그램, 프로세스, 스레드
- 프로그램: 디스크에 저장된 실행 파일입니다.
/usr/bin/node처럼 가만히 있는 파일입니다. - 프로세스: 프로그램이 메모리에 올라가 실행 중인 상태입니다. 같은 프로그램을 두 번 실행하면 프로세스가 두 개 생깁니다. 운영체제는 프로세스마다 고유 번호(PID)를 붙이고, 메모리와 CPU 시간을 나눠 줍니다.
- 스레드: 프로세스 안에서 코드를 실행하는 흐름 하나입니다. 프로세스는 적어도 스레드 하나(메인 스레드)를 가지고, 필요하면 여러 개를 만들어 동시에 실행합니다.
식당으로 비유하면 프로세스는 주방 하나, 스레드는 그 주방에서 일하는 요리사입니다. 요리사들은 같은 냉장고(메모리)와 조리 도구(열린 파일)를 함께 쓰지만, 각자 손에 든 레시피의 몇 번째 줄을 하고 있는지(실행 위치)는 따로 기억합니다. 다른 주방(다른 프로세스)의 냉장고는 열 수 없습니다.
프로세스: 자기만의 메모리를 가진 실행 단위
운영체제는 프로세스마다 독립된 메모리 공간(주소 공간)을 줍니다. 한 프로세스가 다른 프로세스의 메모리를 마음대로 읽거나 고칠 수 없기 때문에, 한 프로그램이 잘못되어도 다른 프로그램까지 망가지지 않습니다. 프로세스의 메모리는 보통 네 영역으로 나눠 설명합니다.
| 영역 | 들어가는 것 | 특징 |
|---|---|---|
| 코드(text) | 실행할 기계어 명령 | 읽기 전용 |
| 데이터 | 전역 변수, static 변수 | 프로그램 시작 때 자리가 정해짐 |
| 힙(heap) | 실행 중에 만든 객체 (new, malloc) | 실행하면서 커지고 줄어듦 |
| 스택(stack) | 함수 호출 정보, 지역 변수 | 함수를 부를 때마다 쌓이고 끝나면 빠짐 |
운영체제는 프로세스를 관리하기 위한 정보를 PCB(Process Control Block)에 모아 둡니다. PID, 현재 상태, CPU 레지스터 값, 메모리 정보, 열린 파일 목록 같은 것들입니다. 리눅스에서는 커널 안의 task_struct 구조체가 이 역할을 하고, 그 내용 일부를 /proc/<PID>/ 아래 파일로 보여 줍니다.
프로세스 상태
프로세스는 만들어져서 끝날 때까지 상태를 바꿔 가며 움직입니다.
| 상태 | 뜻 | 다음으로 |
|---|---|---|
| 생성(New) | 만들어지는 중 | 준비 |
| 준비(Ready) | 실행할 수 있고 CPU 차례를 기다림 | 실행 |
| 실행(Running) | CPU에서 명령을 실행 중 | 준비(차례가 끝남) · 대기(I/O 요청) · 종료 |
| 대기(Waiting) | 디스크·네트워크 같은 I/O가 끝나길 기다림 | 준비(I/O 완료) |
| 종료(Terminated) | 실행이 끝남, 부모가 결과를 거둬 가길 기다림 | 사라짐 |
리눅스 ps의 STAT 열은 이 상태를 글자로 보여 줍니다. 아래 실습에서 보게 될 글자만 정리하면 이렇습니다.
| STAT | 뜻 |
|---|---|
R | 실행 중이거나 실행 대기 중 (Running/Runnable) |
S | 깨울 수 있는 대기 (이벤트를 기다리며 잠듦) |
D | 깨울 수 없는 대기 (주로 디스크 I/O) |
Z | 좀비: 끝났지만 부모가 아직 거둬 가지 않음 |
l (두 번째 글자) | 멀티스레드 프로세스 |
준비 상태의 프로세스 중 누구에게 CPU를 줄지는 CPU 스케줄러가 정합니다. 이 내용은 다음 글에서 다룹니다.
스레드: 프로세스 안의 실행 흐름
같은 프로세스의 스레드들은 코드·데이터·힙·열린 파일을 함께 씁니다. 대신 각자 실행 위치가 달라야 하므로 아래 두 가지는 스레드마다 따로 가집니다.
- 스택: 스레드마다 호출 중인 함수와 지역 변수가 다릅니다.
- 레지스터와 프로그램 카운터(PC): 지금 어느 명령을 실행하고 있는지 기억합니다.
+---------------------- process (PID 1679) ----------------------+
| code | data | heap | open files (shared) |
| |
| [thread A] [thread B] [thread C] |
| stack A stack B stack C |
| registers, PC registers, PC registers, PC |
+----------------------------------------------------------------+함께 쓰는 덕분에 스레드끼리는 변수 하나로 데이터를 주고받을 수 있고, 새 스레드를 만드는 비용도 프로세스보다 작습니다. 하지만 같은 메모리를 여러 스레드가 동시에 고치면 값이 꼬일 수 있습니다. 이 문제(경쟁 조건)와 해결 방법(뮤텍스·세마포어)은 시리즈 4편에서 다룹니다.
리눅스 커널은 프로세스와 스레드를 모두 태스크(task)라는 같은 단위로 스케줄링합니다. 새 스레드는 clone() 시스템 콜에 "메모리와 파일을 부모와 공유하라"는 옵션을 주어 만듭니다. 그래서 리눅스에서는 스레드마다 번호(TID)가 있고, ps에서는 이 번호를 SPID(또는 LWP), 스레드 수를 NLWP(Number of Light-Weight Processes)라고 부릅니다.
프로세스 vs 스레드 한눈에 보기
| 구분 | 프로세스 | 스레드 |
|---|---|---|
| 메모리 | 독립된 주소 공간 | 같은 프로세스의 주소 공간을 공유 (스택·레지스터만 따로) |
| 만드는 비용 | 큼 (주소 공간·자원 준비) | 작음 |
| 데이터 주고받기 | IPC 필요 (파이프, 소켓, 메시지) | 공유 메모리로 바로 (대신 동기화 필요) |
| 하나가 죽으면 | 다른 프로세스는 영향 없음 | 보통 프로세스 전체가 같이 죽음 |
| 리눅스에서 보기 | ps 한 줄 = 프로세스 하나 | ps -T, top -H, /proc/<PID>/task/ |
실습 1: Node.js는 정말 스레드 하나일까?
아무것도 하지 않고 60초 기다리는 Node.js 프로그램을 띄우고 스레드를 세어 봅니다.
$ node -e "setTimeout(()=>{},60000)" &
$ ps -o pid,ppid,nlwp,rss,stat,comm -p <PID>
PID PPID NLWP RSS STAT COMMAND
1659 1656 7 36900 Sl node
$ ps -T -o pid,spid,stat,comm -p <PID>
PID SPID STAT COMMAND
1659 1659 Sl node
1659 1660 Sl DelayedTaskSche
1659 1661 Sl node
1659 1662 Sl node
1659 1663 Sl node
1659 1664 Sl node
1659 1665 Sl node
$ grep Threads /proc/<PID>/status
Threads: 7NLWP가 7이고, STAT의 l이 멀티스레드 프로세스라는 표시입니다. SPID가 PID와 같은 첫 줄이 메인 스레드입니다. 상태가 모두 S인 이유는 할 일이 없어 잠들어 있기 때문입니다.
"싱글 스레드"라는 말은 우리가 쓴 자바스크립트 코드가 메인 스레드 하나에서 실행된다는 뜻입니다. 나머지 스레드는 Node.js와 V8 엔진이 내부 일을 하려고 만든 것입니다. 일부는 옵션을 바꿔 가며 직접 확인할 수 있습니다.
$ node -e "setTimeout(()=>{},3000)" & grep Threads /proc/$!/status
Threads: 7
$ node --v8-pool-size=1 -e "setTimeout(()=>{},3000)" & grep Threads /proc/$!/status
Threads: 4
# 비동기 파일 읽기를 한 번 하면 libuv 스레드 풀이 생깁니다 (크기를 2로 지정)
$ UV_THREADPOOL_SIZE=2 node -e "require('fs').readFile('/etc/hostname',()=>{}); setTimeout(()=>{},3000)" &
$ ps -T -o comm -p $! | tail -n +2 | sort | uniq -c
1 DelayedTaskSche
2 libuv-worker
6 node--v8-pool-size=1로 V8 백그라운드 작업 스레드 풀을 1개로 줄이니 7개가 4개가 되었습니다. 기본값에서는 V8용 스레드가 4개 있었다는 뜻입니다.- 비동기 파일 읽기처럼 운영체제가 비동기로 처리해 주지 못하는 일은 libuv 스레드 풀(
libuv-worker)이 맡습니다. 이 풀은 처음 쓸 때 만들어지고, 크기는UV_THREADPOOL_SIZE로 정합니다. - 7개 중 메인 스레드,
DelayedTaskSche, V8 풀 4개를 빼면 1개가 남습니다. 이 스레드의 역할은 이 글에서 확인하지 않았습니다.
실습 2: 자식 프로세스 vs 워커 스레드
이번에는 한 프로그램에서 자식 프로세스 2개(child_process.fork)와 워커 스레드 2개(worker_threads)를 만들고 차이를 봅니다. 확인할 것은 두 가지입니다.
- 메모리를 공유하는가: 자식 프로세스가 전역 변수를 바꾸면 부모에게 보이는가, 워커 스레드가
SharedArrayBuffer에 쓴 값은 메인 스레드에 보이는가 ps·top에서 어떻게 보이는가
// 프로세스와 스레드 비교 실습
import { fork } from 'node:child_process'
import { Worker } from 'node:worker_threads'
import { readFile } from 'node:fs/promises'
const mode = process.argv[2]
if (mode === 'child') {
// 자식 프로세스: 부모와 메모리를 공유하지 않는다
globalThis.counter = 999
process.send({ pid: process.pid, ppid: process.ppid, counter: globalThis.counter })
setInterval(() => {}, 1000) // 살아 있기만
} else {
globalThis.counter = 0
console.log(`main pid=${process.pid}`)
// 1) libuv 스레드 풀 깨우기 (비동기 파일 읽기)
await readFile(new URL(import.meta.url))
// 2) 자식 프로세스 2개
for (let i = 0; i < 2; i++) {
const child = fork(new URL(import.meta.url), ['child'])
child.on('message', (m) => console.log(`child pid=${m.pid} ppid=${m.ppid} child.counter=${m.counter} main.counter=${globalThis.counter}`))
}
// 3) 워커 스레드 2개: SharedArrayBuffer로 같은 메모리를 본다
const shared = new Int32Array(new SharedArrayBuffer(4))
for (let i = 0; i < 2; i++) {
new Worker(
`const { workerData } = require('node:worker_threads')
Atomics.add(workerData, 0, 1)
const end = Date.now() + 60000
while (Date.now() < end) {} // CPU를 계속 쓰는 스레드`,
{ eval: true, workerData: shared },
)
}
setTimeout(() => console.log(`workers wrote shared[0]=${Atomics.load(shared, 0)}`), 500)
setTimeout(() => process.exit(0), 60000)
}$ node demo.mjs &
main pid=1679
child pid=1692 ppid=1679 child.counter=999 main.counter=0
child pid=1691 ppid=1679 child.counter=999 main.counter=0
workers wrote shared[0]=2- 자식 프로세스는 자기
counter를 999로 바꿨지만 부모의counter는 그대로 0입니다. 주소 공간이 따로이기 때문에, 값을 알려 주려면process.send()같은 IPC(프로세스 간 통신)를 써야 했습니다. - 워커 스레드 2개가 각각 1씩 더한 값이 메인 스레드에서 2로 보입니다.
SharedArrayBuffer는 같은 메모리를 가리키기 때문입니다. 두 스레드가 동시에 더해도 2가 정확히 나온 것은Atomics.add가 원자적으로 더하기 때문입니다. 그냥workerData[0]++로 썼다면 값이 꼬일 수 있습니다(4편 동기화에서 다룹니다).
ps로 보기: 프로세스는 줄, 스레드는 NLWP
$ ps -o pid,ppid,nlwp,rss,stat,comm --ppid 1679 -p 1679
PID PPID NLWP RSS STAT COMMAND
1679 1 13 75504 Sl node
1691 1679 7 41220 Sl node
1692 1679 7 41244 Sl node- 자식 프로세스 2개는 각자 PID를 가진 별도의 줄로 나오고,
PPID(부모 PID)가 1679입니다. 각자 스레드 7개를 가진 완전한 Node.js 프로세스입니다. - 워커 스레드는 줄이 늘지 않고 부모의
NLWP가 7 → 13으로 늘었습니다. 7(기본) + libuv 풀 4 + 워커 2 = 13입니다. - 메인 프로세스의
PPID가 1인 것은 실습 때 백그라운드로 띄운 셸이 먼저 끝나서 PID 1 프로세스가 새 부모가 되었기 때문입니다(고아 프로세스).
ps -T로 스레드를 펼치면 CPU를 쓰는 스레드가 바로 보입니다.
$ ps -T -o pid,spid,stat,pcpu,comm -p 1679
PID SPID STAT %CPU COMMAND
1679 1679 Sl 1.9 node
1679 1681 Sl 0.0 DelayedTaskSche
1679 1682 Sl 0.0 node
1679 1683 Sl 0.0 node
1679 1684 Sl 0.0 node
1679 1685 Sl 0.0 node
1679 1686 Sl 0.0 node
1679 1687 Sl 0.0 libuv-worker
1679 1688 Sl 0.0 libuv-worker
1679 1689 Sl 0.0 libuv-worker
1679 1690 Sl 0.0 libuv-worker
1679 1698 Rl 96.9 node
1679 1699 Rl 96.9 node마지막 두 줄(SPID 1698, 1699)이 while 루프를 도는 워커 스레드입니다. 상태가 R(실행 중)이고 CPU를 거의 100%씩 씁니다. CPU가 2개인 환경이라 두 스레드가 진짜로 동시에 실행되고 있습니다. 메인 스레드는 이벤트를 기다리며 잠들어(S) 있습니다.
top -H로 보기: 스레드마다 같은 메모리
top은 기본적으로 프로세스 단위로 보여 주고, -H를 붙이면 스레드 단위로 보여 줍니다.
$ top -H -b -n 1 -p 1679
Threads: 13 total, 2 running, 11 sleeping, 0 stopped, 0 zombie
%Cpu(s):100.0 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1698 root 20 0 2255564 75504 42612 R 99.9 0.9 0:02.14 node
1699 root 20 0 2255564 75504 42612 R 99.9 0.9 0:02.14 node
1679 root 20 0 2255564 75504 42612 S 0.0 0.9 0:00.04 node
1681 root 20 0 2255564 75504 42612 S 0.0 0.9 0:00.00 DelayedTa+
1687 root 20 0 2255564 75504 42612 S 0.0 0.9 0:00.00 libuv-wor+눈여겨볼 곳은 메모리 열입니다. 13개 스레드 모두 VIRT·RES·SHR이 똑같습니다. 스레드는 자기 메모리가 따로 없고 프로세스의 주소 공간을 함께 쓰기 때문에, top은 스레드마다 같은 프로세스 메모리를 보여 줍니다. 이 숫자를 13번 더하면 안 됩니다.
pstree로 한 번에 보기
$ pstree -pt 1679
node(1679)-+-node(1691)-+-{DelayedTaskSche}(1693)
| |-{node}(1694)
| `- …
|-node(1692)-+-{DelayedTaskSche}(1700)
| `- …
|-{DelayedTaskSche}(1681)
|-{libuv-worker}(1687)
|-{node}(1698)
`-{node}(1699)중괄호 없는 node(1691)은 자식 프로세스, 중괄호가 있는 {node}(1698)은 스레드입니다.
워커 스레드도 공짜는 아니다
이 실습에서 메인 프로세스의 RSS(실제로 쓰는 물리 메모리)는 빈 상태 약 36.9MB에서 워커 2개 등을 띄운 뒤(파일 읽기·자식 프로세스 관리 포함) 약 75.5MB가 되었고, 자식 프로세스는 각각 약 41MB를 썼습니다(한 번 측정한 값이라 환경마다 다릅니다). 워커 스레드는 자바스크립트를 따로 실행할 수 있는 환경을 통째로 하나 더 준비하기 때문에, C 언어의 스레드처럼 스택만 하나 더 생기는 것보다 훨씬 무겁습니다. Node.js 공식 문서도 워커를 작업마다 새로 만들면 만드는 비용이 이득보다 커지기 쉬우니 워커 풀을 쓰라고 안내합니다. 또 워커는 CPU를 많이 쓰는 자바스크립트 작업에 쓰는 것이고, I/O가 많은 작업에는 Node.js의 비동기 I/O가 더 효율적이라고 적고 있습니다.
언제 프로세스, 언제 스레드?
| 상황 | 선택 | 이유 |
|---|---|---|
| 하나가 죽어도 나머지는 살아야 함 | 프로세스 | 메모리가 분리되어 장애가 번지지 않음 |
| 큰 데이터를 자주 주고받는 계산 | 스레드 | 복사 없이 공유 메모리로 전달 |
| Node.js에서 CPU를 많이 쓰는 작업 (이미지 처리, 압축) | 워커 스레드 | 메인 스레드(이벤트 루프)를 막지 않음 |
| Node.js에서 I/O가 많은 서버 | 둘 다 필요 없는 경우가 많음 | 비동기 I/O로 메인 스레드 하나가 처리 |
| CPU 코어 수만큼 서버를 늘리기 | 프로세스 (cluster, PM2, 컨테이너 여러 개) | 서로 독립, 하나가 죽으면 다시 띄움 |
정리
- 프로세스는 실행 중인 프로그램이고 독립된 주소 공간(코드·데이터·힙·스택)을 가집니다. 하나가 잘못되어도 다른 프로세스에 번지지 않습니다.
- 스레드는 프로세스 안의 실행 흐름입니다. 코드·데이터·힙·열린 파일은 함께 쓰고, 스택과 레지스터만 따로 가집니다.
- 리눅스에서는
ps의 한 줄이 프로세스,NLWP가 스레드 수입니다. 스레드는ps -T,top -H,/proc/<PID>/task/로 봅니다.top -H의 메모리 값은 스레드마다 같은 프로세스 메모리입니다. - "Node.js는 싱글 스레드"는 자바스크립트 코드가 메인 스레드 하나에서 실행된다는 뜻입니다. 실제 프로세스에는 V8과 libuv가 만든 스레드가 여럿 있습니다.
- 스레드는 메모리를 공유하기 때문에 빠르지만, 동시에 같은 값을 고치면 꼬입니다. 다음 글에서는 준비 상태의 여러 스레드 중 누가 CPU를 쓸지 정하는 CPU 스케줄링을 다룹니다.
참고 자료
- ps(1) — Linux manual page
- top(1) — Linux manual page
- proc_pid_status(5) — Linux manual page
- clone(2) — Linux manual page
- Worker threads (Node.js 공식 문서)
- Command-line API: --v8-pool-size, UV_THREADPOOL_SIZE (Node.js 공식 문서)
이 글은 AI 도구로 초안을 만들고 저자가 검토·보완했습니다.