105. 부모 프로세스 (Parent Process) / 자식 프로세스 (Child Process)

핵심 인사이트 (3줄 요약)

본질: 부모 프로세스 (Parent Process)와 자식 프로세스 (Child Process)는 fork() 시스템 콜 (System Call)에 의해 형성되는 계층적 프로세스 관계로, 자식은 부모의 PID (Process ID)를 PPID (Parent Process ID)로 기록하며 트리 형태의 프로세스 계층 구조 (Process Hierarchy)를 구성한다.

가치: 이 계층 구조는 자원의 상속과 격리를 동시에 실현하여, 셸 (Shell) 명령어 실행, 웹 서버의 요청 처리, 파이프라인 연산 등 운영체제 전반의 병렬 처리 모델을 안정적으로 동작하게 하는 구조적 기반이다.

융합: 현대 리눅스 (Linux) 커널에서 PID 네임스페이스 (PID Namespace)를 통해 컨테이너 (Container)별로 독립적인 프로세스 트리를 구성하며, systemd init 시스템이 최상위 부모로서 전체 프로세스 수명주기를 관리하는 클라우드 네이티브 인프라의 핵심 개념이다.

Ⅰ. 개요 및 필요성 (Context & Necessity)

개념: 유닉스 (Unix) 계열 운영체제에서 fork() 시스템 콜을 호출하면, 호출한 프로세스(부모)의 PCB (Process Control Block), 주소 공간, 파일 디스크립터 테이블 등이 복제되어 새로운 프로세스(자식)가 생성된다. 자식의 PCB에는 자신을 생성한 부모의 PID가 PPID (Parent Process ID) 필드에 기록되며, 이로써 모든 프로세스는 트리 (Tree) 형태의 계층 구조를 형성한다. 부모는 wait() 또는 waitpid() 시스템 콜을 통해 자식의 종료 상태(Exit Status)를 회수하며, 자식이 종료되기 전에 부모가 먼저 종료되면 자식은 init 프로세스(PID 1)에 의뢰되어 고아 (Orphan) 프로세스로 전환된다.
필요성: 단일 프로세스만으로는 여러 작업을 동시에 수행할 수 없다. 사용자가 셸에서 명령어를 실행할 때마다 셸 프로세스 자신이 새 프로그램으로 변환되면 명령어 실행 후 셸로 돌아올 수 없다. 따라서 셸은 자신의 복사본(자식)을 만들어 명령어를 실행하게 하고, 자신은 자식의 종료를 기다리는(wait) 구조가 필수적이다. 또한, 부모-자식 간의 자원 상속 메커니즘은 파일 디스크립터, 환경 변수, 작업 디렉터리 등을 자동으로 전달하므로, 프로세스 간 협력을 위한 IPC (Inter-Process Communication) 설정 비용을 극적으로 절감한다.
비유: 부모 프로세스는 회사의 본사이고, 자식 프로세스는 본사에서 파견된 지사와 같다. 지사는 본사의 자본과 시스템(자원 상속)을 물려받아 독립적으로 사업을 수행하며, 작업이 끝나면 결과 보고서(종료 상태)를 본사에 제출(wait)한다. 본사가 먼저 문을 닫으면 지사는 본부(init)에 보고하도록 지정된다.
등장 배경 및 발전 과정:
1. 초기 유닉스의 단일 프로세스 모델: 최초의 유닉스 시스템에서는 한 번에 하나의 프로그램만 실행할 수 있었고, 새 프로그램을 실행하려면 기존 프로세스를 종료해야 했다.
2. fork()의 도입 (1970년대): 켄 톰슨 (Ken Thompson)과 데니스 리치 (Dennis Ritchie)가 부모의 완전한 복사본을 생성하는 fork()를 고안하여 프로세스 계층 구조를 가능하게 했다.
3. PID Namespace와 컨테이너의 발전: 리눅스 커널 2.6.24(2008년)에서 PID 네임스페이스가 도입되어, 각 컨테이너 내부에서 독립적인 PID 1(init)을 가지는 프로세스 트리를 구성할 수 있게 되었다.

부모-자식 프로세스 간의 계층 구조와 핵심 식별자(PID, PPID)의 관계를 시각화하면 프로세스 트리의 전체 구조를 직관적으로 파악할 수 있다.

  ┌───────────────────────────────────────────────────────────────────────┐
  │               프로세스 트리 (Process Tree) 구조와 PID/PPID 관계       │
  ├───────────────────────────────────────────────────────────────────────┤
  │                                                                       │
  │  PID=1 (PPID=0)                                                       │
  │  ┌─────────────────────┐                                              │
  │  │  systemd (init)     │  ◀── 최상위 부모: 모든 프로세스의 조상       │
  │  └────────┬────────────┘                                              │
  │           │ fork()                                                    │
  │     ┌─────┴─────┬──────────────┐                                      │
  │     ▼           ▼              ▼                                      │
  │  PID=500    PID=600       PID=700                                     │
  │  ┌────────┐ ┌────────┐  ┌────────────┐                                │
  │  │sshd    │ │ httpd  │  │  cron      │                                │
  │  │PPID=1  │ │PPID=1  │  │  PPID=1    │                                │
  │  └───┬────┘ └───┬────┘  └────────────┘                                │
  │      │ fork()    │ fork()                                             │
  │      ▼           ▼                                                    │
  │  PID=1000   PID=1100  PID=1101  ...                                   │
  │  ┌────────┐ ┌────────┐ ┌────────┐                                     │
  │  │ bash   │ │worker-1│ │worker-2│  ◀── 자식 프로세스들                │
  │  │PPID=500│ │PPID=600│ │PPID=600│                                     │
  │  └───┬────┘ └────────┘ └────────┘                                     │
  │      │ fork()                                                         │
  │      ▼                                                                │
  │  PID=1001                                                             │
  │  ┌──────────┐                                                         │
  │  │   ls     │  ◀── bash의 자식: ls 종료 후 wait()로 상태 회수         │
  │  │ PPID=1000│                                                         │
  │  └──────────┘                                                         │
  └───────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] 이 트리 구조의 핵심은 PID (Process ID)와 PPID (Parent Process ID)의 방향성이다. 모든 프로세스는 고유한 PID를 부여받으며, 자신을 생성한 부모의 PID를 PPID로 저장한다. 최상위 프로세스인 init(PID 1, 현대 리눅스에서는 systemd)은 PPID가 0이며 운영체제 부팅 시 커널에 의해 최초로 생성된다. fork() 호출은 트리에서 새로운 가지를 뻗는 동작에 해당한다. bash 셸(PID 1000)이 사용자 명령어로 ls를 실행할 때, bash는 자식(PID 1001)을 fork하고 자식이 종료되면 wait()로 종료 상태를 회수한다. 부모가 먼저 종료되면 자식의 PPID는 1(init)로 재설정되어 고아 프로세스로 전환된다.

📢 섹션 요약 비유: 가족 족보에서 할아버지(init)를 뿌리로 삼아 아버지(부모)가 아들(자식)을 낳고, 아들이 작업을 마치면 아버지에게 결과를 보고하는(wait) 가족 공동체의 체계와 같습니다.

Ⅱ. 아키텍처 및 핵심 원리 (Deep Dive)

PID, PPID, 프로세스 트리의 핵심 동작 원리

부모-자식 관계를 구성하는 핵심 데이터 구조는 PCB 내부의 PID와 PPID 필드다. 리눅스 커널에서 프로세스는 task_struct 구조체로 표현되며, 이 구조체에는 부모를 가리키는 parent 포인터와 자식 리스트를 관리하는 children 연결 리스트가 포함되어 있다.

요소명	역할	내부 동작	관련 기술	비유
PID (Process ID)	프로세스의 고유 식별자	커널의 PID 할당자(bitmap)가 중복 없이 순차 또는 재사용 할당	`task_struct->pid`	주민등록번호
PPID (Parent PID)	부모 프로세스의 식별자	`fork()` 시 현재 프로세스의 PID를 자식의 PPID 필드에 복사	`task_struct->parent->pid`	부모의 주민등록번호
프로세스 트리 (Process Tree)	전체 프로세스의 계층 구조	`task_struct`의 `children`/`sibling` 리스트로 트리 형성	`pstree` 명령어	족보 (Family Tree)
wait()/waitpid()	자식 종료 상태 회수	자식이 좀비 상태가 되면 커널이 부모를 깨워 종료 코드 전달	`SIGCHLD` 시그널	결과 수령 확인서

부모 프로세스가 자식을 fork()하고, wait()로 종료를 대기하는 전체 라이프사이클을 시퀀스 다이어그램으로 표현하면 동기화 메커니즘을 명확히 이해할 수 있다.

  ┌───────────────────────────────────────────────────────────────────────┐
  │         부모-자식 프로세스의 fork() → exec() → wait() 생명주기        │
  ├───────────────────────────────────────────────────────────────────────┤
  │                                                                       │
  │  [Parent Process]           [Kernel]              [Child Process]     │
  │       │                       │                       │               │
  │       │── fork() ────────────▶│                       │               │
  │       │                       │── PCB 복제 ──────────▶│               │
  │       │                       │   PID 할당             │              │
  │       │◀── PID=1001 반환 ─────│                       │               │
  │       │                       │                       │               │
  │       │                       │                       │──exec()──▶    │
  │       │                       │                       │  (메모리 교체)│
  │       │                       │                       │               │
  │       │── waitpid(1001) ─────▶│  (부모는 블로킹 대기)   │             │
  │       │   (수면 상태로 진입)    │                       │             │
  │       │                       │                       │──exit()──▶    │
  │       │                       │◀── 좀비 상태로 전환 ──│  (종료코드:0) │
  │       │                       │   SIGCHLD 전송 ───────│───▶           │
  │       │◀─ 종료 상태 회수 ─────│                       │               │
  │       │   (자식 PCB 해제)      │── 좀비 해제 ─────────▶│              │
  │       │                       │                       │               │
  │  [정상 복귀]                     │              [완전 소멸]           │
  └───────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] 이 시퀀스 다이어그램은 fork-exec-wait 패턴의 세 가지 핵심 동작 단계를 보여준다. 첫째, fork() 시 커널은 부모의 task_struct를 복제하고 새로운 PID를 할당하여 자식을 생성하며, 부모에게는 자식의 PID를, 자식에게는 0을 반환한다. 둘째, 자식은 exec()를 통해 자신의 주소 공간을 새로운 프로그램으로 완전히 교체한다. 셋째, 부모는 waitpid()를 호출하여 블로킹 상태로 대기하며, 자식이 exit()를 호출하면 커널이 자식을 좀비 상태로 전환하고 부모에게 SIGCHLD 시그널을 전송한다. 부모가 waitpid()에서 복귀하여 종료 상태를 회수하면 비로소 자식의 PCB가 해제되고 프로세스가 완전히 소멸한다.

wait()와 waitpid()의 차이

항목	wait()	waitpid(pid_t pid, int *status, int options)
대상	임의의 자식 하나가 종료될 때까지 대기	특정 PID의 자식 또는 그룹 단위 대기 가능
논블로킹	항상 블로킹	`WNOHANG` 옵션으로 논블로킹 대기 가능
사용 빈도	단일 자식 관리 시	다중 자식 병렬 관리 시 (서버 등)

📢 섹션 요약 비유: 본사(부모)에서 지사(자식)를 세우고, 지사장이 사업을 마치면 본사에 결과 보고서(exit status)를 제출하도록 한 뒤, 본사가 도장을 찍어 수령(wait)할 때까지 서류(좀비)를 보관하는 체계적인 관리 시스템과 같습니다.

Ⅲ. 융합 비교 및 다각도 분석

부모-자식 관계의 다양한 실무 패턴

실무에서 부모-자식 프로세스 관계는 다양한 패턴으로 활용되며, 각 패턴에 따라 wait() 호출 전략이 달라진다.

패턴	설명	wait() 전략	대표 예시
단일 자식 실행	부모가 하나의 자식만 fork하고 종료를 기다림	`wait()` 단일 호출	셸에서 명령어 하나 실행
순차 자식 실행	여러 자식을 순차적으로 fork하고 순서대로 종료 대기	`wait()`를 N번 반복 호출	빌드 스크립트의 순차 컴파일
병렬 자식 실행	여러 자식을 동시에 fork하고 모두 종료를 대기	`waitpid()`에 `WNOHANG` 사용하여 루프	웹 서버의 동시 요청 처리
데몬 (Daemon) 화	부모가 fork 후 즉시 exit하여 자식을 init의 자식으로 이전	부모는 `wait()` 없이 exit	`daemon()` 함수의 double-fork 기법

  ┌──────────────────────────────────────────────────────────────────────┐
  │         부모-자식 관계 4가지 패턴의 fork/wait 전략 비교              │
  ├──────────────────────────────────────────────────────────────────────┤
  │                                                                      │
  │  [A] 단일 자식                    [B] 순차 자식                      │
  │  Parent ──fork()──▶ Child1       Parent ──fork()──▶ Child1           │
  │    │                    │             │ wait()      │                │
  │    │ wait()             │ exit()      │ fork()      │ exit()         │
  │    │ ◀── 종료 상태 ─────┘             │ wait()      │                │
  │    │                                  │ fork()──▶ Child2             │
  │    │                                             │ exit()            │
  │    │                                  wait()      │                  │
  │                                                                      │
  │  [C] 병렬 자식                    [D] 데몬화 (double-fork)           │
  │  Parent──fork()──▶ Child1           Parent──fork()──▶ Middle         │
  │  Parent──fork()──▶ Child2             │ exit()         │             │
  │  Parent──fork()──▶ Child3             ▼                │ fork()      │
  │    │                                  GrandParent=init│──▶ Daemon    │
  │    │ while(waitpid(WNOHANG)>0)        (PPID=1)        │              │
  │    │   // 논블로킹으로 모든 자식 상태 회수                           │
  └──────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] 네 가지 패턴은 부모-자식 관계의 유연성을 보여준다. [A] 단일 자식 패턴은 셸의 기본 동작으로, 가장 단순한 wait() 호출로 종료 상태를 회수한다. [B] 순차 패턴은 빌드 파이프라인에서 자주 쓰이며, 이전 자식이 완전히 종료된 후 다음 자식을 fork한다. [C] 병렬 패턴은 웹 서버에서 핵심적이며, WNOHANG 플래그를 사용한 비블로킹 폴링으로 자식 상태를 회수하면서 부모는 다른 작업을 동시에 수행할 수 있다. [D] 데몬화 패턴은 double-fork 기법으로, 중간 프로세스(부모)가 즉시 exit하면 손자(데몬)의 PPID가 init(PID 1)이 되어 터미널과 완전히 분리된 백그라운드 프로세스로 동작한다.

📢 섹션 요약 비유: 한 명의 비서(단일 자식)를 데리고 일을 시키는 것도, 여러 명(병렬 자식)에게 동시에 업무를 분담시키는 것도, 사원을 정식 직원(init의 자식)으로 전입시켜 독립적으로 일하게 하는 것(데몬화)도 모두 조직의 효율적 운영 전략과 같습니다.

Ⅳ. 실무 적용 및 기술사적 판단

실무 시나리오

시나리오 — 웹 서버의 좀비 누적 방지: 대규모 트래픽을 처리하는 아파치 HTTP 서버(Apache httpd)의 MPM (Multi-Processing Module) Prefork 모드에서는 각 요청마다 자식 프로세스를 fork한다. 한때 부모 프로세스의 시그널 핸들러 설정 오류로 SIGCHLD가 무시(Ignored)되어 수만 개의 좀비가 누적되고, PID 고갈로 새로운 요청을 처리할 수 없는 장애가 발생했다. 엔지니어는 waitpid(-1, &status, WNOHANG)을 시그널 핸들러에 등록하여, 좀비가 생성될 때마다 즉시 회수하는 비동기 수확(Reaping) 패턴을 적용하여 문제를 해결했다.
시나리오 — 컨테이너의 PID 1 문제: 도커 (Docker) 컨테이너 내부에서 실행된 애플리케이션이 자식 프로세스를 fork하고 wait()를 호출하지 않아 좀비가 누적되었다. 컨테이너의 PID 1은 애플리케이션 자신이므로 init처럼 고아를 회수하지 못했고, 결국 컨테이너 내 PID가 고갈되어 서비스가 중단되었다. 해결책으로 tini나 dumb-init 같은 경량 init 프로세스를 컨테이너의 PID 1로 설정하여, 고아와 좀비를 자동 회수하도록 아키텍처를 개선했다.

도입 체크리스트

기술적: fork() 생성한 모든 자식에 대해 wait() 또는 waitpid()가 호출되는 경로가 보장되는가? SIGCHLD 시그널 핸들러 또는 SIG_IGN 설정이 올바르게 구성되어 있는가?
운영적: pstree -p 명령어로 프로세스 트리를 정기적으로 점검하여 고아나 좀비 프로세스가 누적되지 않는지 모니터링하고 있는가?

안티패턴

wait() 누락 (Zombie Leak): 자식을 fork하고 wait()를 호출하지 않으면 자식이 종료된 후 좀비 상태로 무한히 누적되어 PID 고갈을 초래한다. 서버 프로그램에서는 반드시 시그널 핸들러 내에서 waitpid()를 호출하거나, SIGCHLD를 SIG_IGN으로 설정하여 커널이 자동 회수하도록 해야 한다.
📢 섹션 요약 비유: 본사에서 지사를 세우고 폐업 후 정리(wait)를 하지 않으면 빈 건물(좀비)만 계속 쌓여 새 지사를 지을 땅이 없어지듯, 반드시 종료된 자식의 상태를 회수해야 시스템 자원이 고갈되지 않습니다.

Ⅴ. 기대효과 및 결론

정량/정성 기대효과

구분	프로세스 계층 구조 미활용	프로세스 계층 구조 활용	개선 효과
정량	단일 프로세스로 직렬 처리	fork로 병렬 처리 후 wait 동기화	처리량(Throughput) N배 향상 (N=자식 수)
정량	자원 상속을 수동으로 설정	fork()에 의해 파일, 환경변수 자동 상속	초기화 코드량 90% 감소
정성	프로세스 간 관계를 파악할 수 없음	pstree로 전체 계층 구조 시각화	운영 환경의 장애 원인 추적 효율 대폭 향상

미래 전망

cgroup과 프로세스 계층의 통합: systemd와 cgroup (Control Group)을 결합하면, 프로세스 트리 단위로 CPU, 메모리, I/O 자원을 격리하고 제한할 수 있어 클라우드 환경의 멀티테넌시(Multi-tenancy) 자원 관리가 한층 정교해지고 있다.
PID Namespace의 중첩: 컨테이너 내부에서 중첩된 PID 네임스페이스를 통해, 각 컨테이너가 독립적인 init 프로세스와 프로세스 트리를 가지면서도 호스트의 자원 제한을 준수하는 보안 격리 아키텍처가 표준화되고 있다.

참고 표준

POSIX.1: fork(), wait(), waitpid(), getpid(), getppid() 시스템 콜 표준.
리눅스 커널 task_struct: /include/linux/sched.h에 정의된 프로세스 디스크립터 구조체.

부모-자식 프로세스 관계는 유닉스 계열 운영체제의 근간을 이루는 계층적 프로세스 모델로, fork()를 통한 생성, wait()를 통한 종료 상태 회수, 그리고 PPID를 통한 계층 추적이라는 세 가지 축으로 구성된다. 이 모델은 50년 이상 운영체제의 기본 아키텍처로 유지되며, 컨테이너 기술의 발전과 함께 프로세스 격리와 수명주기 관리의 현대적 진화를 이끌고 있다.

📢 섹션 요약 비유: 거대한 기업 조직도에서 본사(init)를 정점으로 부서(부모)가 팀(자식)을 산하에 두고, 팀의 성과(종료 상태)를 부서가 확인(wait)하며, 부서가 폐지되면 팀은 본사 직할로 전속(init 양자)되는 조직 관리 체계가 바로 운영체제의 프로세스 계층 구조입니다.

개념 명칭	관계 및 시너지 설명
PID (Process ID)	부모-자식 관계에서 각 프로세스를 고유하게 식별하는 정수값으로, 프로세스 트리의 노드(Node)를 구성하는 핵심 식별자다.
PPID (Parent PID)	자식 프로세스의 PCB에 저장된 부모의 PID로, 프로세스 트리의 간선(Edge)을 형성하여 계층 구조를 명확히 한다.
fork() 시스템 콜	부모 프로세스의 복사본으로 자식을 생성하여 부모-자식 관계를 형성하는 핵심 시스템 콜이다.
wait() / waitpid()	부모가 자식의 종료 상태를 회수하여 좀비 프로세스를 해제하고, 프로세스 생명주기를 정상적으로 완료하는 동기화 메커니즘이다.
좀비 프로세스 (Zombie Process)	자식이 종료되었으나 부모가 wait()를 호출하지 않아 프로세스 테이블에 잔존하는 상태로, 부모-자식 관계 관리 실패의 대표적 결과다.
고아 프로세스 (Orphan Process)	부모가 자식보다 먼저 종료되어 PPID가 init(PID 1)으로 재설정된 프로세스로, init이 양자로서 수거하는 안전한 상태다.

어린이를 위한 3줄 비유 설명

엄마(부모 프로세스)가 아기(자식 프로세스)를 낳으면 아기는 엄마의 집(자원)을 똑같이 물려받아 자기만의 방에서 살게 돼요.
아기가 장난감 놀이(프로그램 실행)를 끝내면 "다 했어요!"라고 엄마에게 보고(wait)해야 하고, 엄마가 확인하면 아기의 방은 깨끗이 치워져요.
만약 엄마가 먼저 집을 나가면 아이는 할아버지(init)가 대신 돌봐주어, 아이가 혼자 남겨지는 일은 절대 없답니다.