Hanpy's Blog

두 글자 이상 입력하세요.

CS 기초 · 운영체제

프로세스와 스레드: ps와 top -H로 직접 확인하기

프로세스는 독립된 메모리를 가진 실행 중인 프로그램이고, 스레드는 그 안에서 메모리를 함께 쓰는 실행 흐름입니다. 둘의 차이를 표로 정리하고, Node.js 프로그램을 띄워 ps·top -H·/proc으로 프로세스와 스레드를 직접 세어 봅니다.

Hanpy약 12분

"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): 지금 어느 명령을 실행하고 있는지 기억합니다.
한 프로세스 안의 스레드 3개 (shared = 함께 씀)
+---------------------- 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.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:	7

NLWP가 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개가 남습니다. 이 스레드의 역할은 이 글에서 확인하지 않았습니다.
Node.js CPU·메모리 사용량 모니터링 방법 보기 (클릭)

실습 2: 자식 프로세스 vs 워커 스레드

이번에는 한 프로그램에서 자식 프로세스 2개(child_process.fork)와 워커 스레드 2개(worker_threads)를 만들고 차이를 봅니다. 확인할 것은 두 가지입니다.

  1. 메모리를 공유하는가: 자식 프로세스가 전역 변수를 바꾸면 부모에게 보이는가, 워커 스레드가 SharedArrayBuffer에 쓴 값은 메인 스레드에 보이는가
  2. ps·top에서 어떻게 보이는가
demo.mjs
// 프로세스와 스레드 비교 실습
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 (직접 실행)
$ 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 (직접 실행, 일부)
$ 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 (직접 실행, 일부)
$ 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가 더 효율적이라고 적고 있습니다.

child_process.fork 다시 보기 (클릭) 브라우저의 Web Worker API와 비교해 보기 (클릭)

언제 프로세스, 언제 스레드?

상황선택이유
하나가 죽어도 나머지는 살아야 함프로세스메모리가 분리되어 장애가 번지지 않음
큰 데이터를 자주 주고받는 계산스레드복사 없이 공유 메모리로 전달
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 스케줄링을 다룹니다.

참고 자료

이 글은 AI 도구로 초안을 만들고 저자가 검토·보완했습니다.