107. 프로세스 종료 (Process Termination) - exit(), wait()

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

본질: 프로세스 종료 (Process Termination)는 실행 중인 프로세스가 운영체제에 자원 반환을 요청하여 생명주기를 마감하는 과정으로, 정상 종료 (Normal Termination)와 비정상 종료 (Abnormal Termination) 두 가지 경로가 존재하며, 유닉스 (Unix)에서는 exit() 시스템 콜 (System Call) 또는 시그널 (Signal)을 통해 수행된다.

가치: 종료 프로세스는 프로세스가 점유하던 메모리, 열린 파일 디스크립터 (File Descriptor), 세마포어 (Semaphore) 등의 시스템 자원을 자동으로 회수하여 자원 누수 (Resource Leak)를 방지하고, 종료 상태 (Exit Status)를 부모 프로세스에 전달하여 실행 결과의 추적 가능성을 보장한다.

융합: 현대 운영체제에서 프로세스 종료는 단순한 소멸이 아니라, 부모-자식 동기화(wait), 고아 프로세스의 init 양자, 좀비 프로세스의 방지라는 프로세스 생명주기 관리의 핵심 축을 이루며, systemd, 쿠버네티스 (Kubernetes)와 같은 프로세스 오케스트레이터 (Orchestrator)가 종료 신호(SIGTERM, SIGKILL)를 통해 우아한 종료 (Graceful Shutdown)를 관리하는 클라우드 네이티브 인프라의 기본 동작이다.

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

개념: 프로세스 종료는 프로세스가 더 이상 실행을 지속하지 않고 운영체제에 자원 반환을 요청하는 과정이다. 유닉스 계열 운영체제에서 프로세스 종료는 크게 두 가지 경로로 발생한다. 첫째, 정상 종료 (Normal Termination)는 프로세스가 스스로 exit() 시스템 콜을 호출하거나 main() 함수에서 return문을 실행하여 종료하는 것이다. 둘째, 비정상 종료 (Abnormal Termination)는 프로세스가 SIGKILL(강제 종료), SIGSEGV(세그멘테이션 폴트), SIGABRT(중단) 등의 시그널을 수신하거나, 치명적인 오류(예: 널 포인터 참조, 정수 오버플로우)로 인해 운영체제가 프로세스를 강제로 종료시키는 것이다.
필요성: 프로세스가 종료될 때 운영체제는 해당 프로세스가 점유한 모든 자원을 반드시 회수해야 한다. 열린 파일 디스크립터, 할당된 메모리 페이지, 사용 중인 세마포어 및 뮤텍스 (Mutex), 네트워크 소켓 (Socket) 등을 방치하면 전체 시스템의 자원이 점진적으로 고갈되어 결국 새로운 프로세스조차 생성할 수 없는 상태에 이른다. 또한, 종료 상태(Exit Status)를 부모에게 전달하여 프로세스의 실행 결과(성공/실패, 에러 코드)를 추적 가능하게 하는 것은 병렬 시스템의 신뢰성 관리에 필수적이다.
비유: 프로세스 종료는 직장인의 퇴사와 같다. 정상 퇴사(exit)는 사직서를 제출하고 업무 인수인계(자원 반환)를 마친 뒤 깔끔하게 퇴근하는 것이며, 비정상 퇴사(SIGKILL)는 갑작스러운 해고로 책상 위의 서류(자원)가 정리되지 않은 채 쫓겨나는 것이다. 어느 경우든 인사팀(OS)은 사번(PID)을 말소하고 자리(PCB)를 회수해야 한다.
등장 배경 및 발전 과정:
1. 초기 시스템의 갑작스러운 종료: 초기 운영체제에서는 프로세스가 오류로 종료되면 파일 디스크립터와 메모리가 회수되지 않아 시스템 재부팅이 필요한 경우가 많았다.
2. exit() 시스템 콜의 표준화: 유닉스에서 exit()가 자동으로 열린 파일을 닫고 버퍼를 플러시(Flush)하며 메모리를 해제하는 정리 과정(Cleanup)을 수행하도록 표준화되었다.
3. 우아한 종료 (Graceful Shutdown): 현대의 서비스 환경에서는 SIGTERM으로 프로세스에게 정리할 기회를 주고, 일정 시간 내 응답하지 않으면 SIGKILL로 강제 종료하는 두 단계 종료 패턴이 표준으로 자리 잡았다.

정상 종료와 비정상 종료의 전체 경로를 상태 전이도로 시각화하면, 각 경로에서의 자원 회수와 상태 전이를 명확히 이해할 수 있다.

  ┌───────────────────────────────────────────────────────────────────────┐
  │              프로세스 종료 경로: 정상 종료 vs 비정상 종료             │
  ├───────────────────────────────────────────────────────────────────────┤
  │                                                                       │
  │                    [Running]                                          │
  │                        │                                              │
  │            ┌───────────┴───────────┐                                  │
  │            ▼                       ▼                                  │
  │  ┌──────────────────┐    ┌──────────────────┐                         │
  │  │  정상 종료          │    │  비정상 종료        │                   │
  │  │  (Normal)         │    │  (Abnormal)       │                       │
  │  └────────┬─────────┘    └────────┬─────────┘                         │
  │           │                       │                                   │
  │  exit() 또는              SIGKILL / SIGSEGV /                         │
  │  main() return           SIGABRT / SIGFPE                             │
  │           │                       │                                   │
  │           ▼                       ▼                                   │
  │  ┌──────────────────────────────────────────┐                         │
  │  │        커널의 종료 처리 (Cleanup)           │                      │
  │  │  1. atexit() 등록 함수 실행                  │                     │
  │  │  2. 열린 FD(File Descriptor) 닫기           │                      │
  │  │  3. 표준 I/O 버퍼 플러시 (Flush)             │                     │
  │  │  4. 메모리 페이지 해제                       │                     │
  │  │  5. 종료 상태(Exit Status)를 PCB에 기록      │                     │
  │  └──────────────┬───────────────────────────┘                         │
  │                 │                                                     │
  │                 ▼                                                     │
  │          ┌──────────────┐                                             │
  │          │  Zombie (좀비) │ ◀── 부모가 wait()할 때까지 대기           │
  │          │  Exit Status  │     PCB만 남아있는 상태                    │
  │          └──────┬───────┘                                             │
  │                 │                                                     │
  │         wait() 또는                                                   │
  │         init 수거                                                     │
  │                 ▼                                                     │
  │          ┌──────────────┐                                             │
  │          │  Removed     │ ◀── PCB 완전 해제, PID 재사용 가능          │
  │          └──────────────┘                                             │
  └───────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] 이 다이어그램은 프로세스 종료의 핵심 특징을 세 가지로 보여준다. 첫째, 정상 종료와 비정상 종료는 경로가 다르지만, 커널의 종료 처리 단계에서 합류한다. 정상 종료 시에는 atexit()에 등록된 사용자 정의 정리 함수가 실행되고 버퍼가 플러시되지만, SIGKILL 등에 의한 비정상 종료에서는 이러한 사용자 수준 정리가 건너뛰어진다. 둘째, 종료 후 프로세스는 즉시 소멸하지 않고 좀비(Zombie) 상태로 전환된다. 좀비 상태에서는 실행 자원(메모리, FD 등)은 모두 회수되었지만, PCB의 종료 상태 항목만 보존된다. 셋째, 부모가 wait()를 호출하거나 init 프로세스가 고아를 수거할 때 비로소 PCB가 완전히 해제되고 PID가 재사용 가능해진다.

📢 섹션 요약 비유: 병원에서 환자(프로세스)가 퇴원(종료)할 때, 정상 퇴원은 의사의 퇴원 확인서(exit)를 받고 짐을 정리하지만, 응급 이송(비정상 종료)은 즉시 병상을 비워야 하며, 어느 경우나 병원(OS)은 진료기록부(PCB)를 보관했다가 가족(wait)이 확인하면 비로소 폐기합니다.

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

정상 종료와 비정상 종료의 세부 메커니즘

요소명	역할	내부 동작	관련 기술	비유
exit(int status)	프로세스 스스로 종료 요청	커널에 종료 상태를 전달하고 정리 과정 시작	`_exit()` (시스템 콜), `exit()` (라이브러리 함수)	자발적 퇴사
return from main()	main 함수 종료로 간접 종료	C 런타임이 `exit(return_value)`를 자동 호출	C/C++ 표준 런타임	업무 완료 후 퇴근
SIGTERM (15)	우아한 종료 요청	프로세스가 시그널 핸들러에서 정리 후 exit() 호출 가능	`kill -15 PID`	퇴사 권고
SIGKILL (9)	강제 즉시 종료	커널이 프로세스를 즉시 종료, 사용자 수준 정리 불가	`kill -9 PID`	강제 해고
SIGSEGV (11)	메모리 접근 위반 종료	잘못된 메모리 주소 접근 시 커널이 프로세스 강제 종료	코어 덤프 (Core Dump)	안전 사고로 퇴출

exit() 시스템 콜이 호출되면 커널이 수행하는 정리 과정의 세부 단계를 시각화하면, 자원 회수의 철저함을 파악할 수 있다.

  ┌───────────────────────────────────────────────────────────────────────────────────────┐
  │               exit() 호출 후 커널의 정리 (Cleanup) 파이프라인                         │
  ├───────────────────────────────────────────────────────────────────────────────────────┤
  │                                                                                       │
  │  exit(status) 호출                                                                    │
  │       │                                                                               │
  │       ▼                                                                               │
  │  [1] 사용자 수준 정리 (exit() 라이브러리 함수)                                        │
  │  ┌────────────────────────────────────────┐                                           │
  │  │  - atexit()에 등록된 핸들러 순차 실행       │                                      │
  │  │  - stdio 버퍼 플러시 (미출력 데이터 디스크 기록)│                                  │
  │  │  - tmpfile()로 생성된 임시 파일 삭제         │                                     │
  │  └──────────────┬─────────────────────────┘                                           │
  │                 │                                                                     │
  │       _exit(status) → 커널 진입                                                       │
  │                 │                                                                     │
  │                 ▼                                                                     │
  │  [2] 커널 수준 정리 (_exit() 시스템 콜)                                               │
  │  ┌────────────────────────────────────────┐                                           │
  │  │  - 자식 프로세스가 존재하면 모두 init(PID=1)에 양자          │                     │
  │  │  - 열린 파일 디스크립터(FD) 모두 닫기        │                                     │
  │  │  - 프로세스 주소 공간의 물리 메모리 해제     │                                     │
  │  │  - 프로세스가 소유한 세마포어, 뮤텍스 해제   │                                     │
  │  │  - PCB에 종료 상태(Exit Status) 기록        │                                      │
  │  │  - 프로세스 상태를 ZOMBIE로 변경             │                                     │
  │  │  - 부모에게 SIGCHLD 시그널 전송             │                                      │
  │  └────────────────────────────────────────┘                                           │
  │                                                                                       │
  │  주의: SIGKILL로 강제 종료 시 [1] 사용자 수준 정리는 건너뜀!                          │
  └───────────────────────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] exit() 프로세스는 두 단계로 구성된다. 첫 번째 단계는 C 라이브러리의 exit() 함수가 수행하는 사용자 수준 정리로, atexit()에 등록된 콜백을 실행하고 표준 I/O 버퍼에 남아있는 데이터를 디스크에 플러시한다. 두 번째 단계는 _exit() 시스템 콜을 통해 커널이 수행하는 정리로, 자식 프로세스의 양자 이전, 파일 디스크립터 폐쇄, 물리 메모리 회수, 동기화 객체 해제 등 운영체제 수준의 자원 정리를 수행한다. 핵심은 SIGKILL로 강제 종료될 경우 첫 번째 단계(사용자 수준 정리)가 완전히 건너뛰어지므로, 버퍼에 남아있는 데이터가 유실될 수 있다는 점이다. 이것이 서비스 운영에서 SIGTERM -> 대기 -> SIGKILL의 두 단계 종료 패턴을 사용해야 하는 근본 이유다.

주요 종료 시그널 비교

시그널	번호	발생 원인	프로세스 차단 가능?	코어 덤프?
SIGHUP	1	터미널 연결 끊김	가능 (기본: 종료)	아니오
SIGINT	2	Ctrl+C 입력	가능 (기본: 종료)	아니오
SIGQUIT	3	Ctrl+\ 입력	가능 (기본: 종료+코어 덤프)	예
SIGKILL	9	`kill -9` 명령	불가 (항상 종료)	아니오
SIGSEGV	11	잘못된 메모리 접근	불가 (기본: 종료+코어 덤프)	예
SIGTERM	15	`kill` 명령 (기본값)	가능 (기본: 종료)	아니오

📢 섹션 요약 비유: 정상 종료(exit)는 퇴사 전 업무 인수인계(atexit 핸들러)를 마치고 정리된 상태로 퇴근하는 것이고, SIGKILL은 건너뛰고 강제로 쫓겨나는 것이므로, 시스템 관리자는 반드시 먼저 정중한 퇴사 요청(SIGTERM)을 해야 합니다.

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

정상 종료 코드의 의미와 POSIX 표준

POSIX.1 표준은 종료 상태(Exit Status)를 8비트(0~255) 범위로 규정하며, 하위 8비트는 프로세스가 exit()에 전달한 값이고, 시그널에 의한 비정상 종료 시에는 상위 비트에 시그널 번호가 기록된다.

종료 코드	의미	발생 상황
0	정상 종료 (Success)	`exit(0)`, `main()`이 0을 반환
1	일반적 오류 (General Error)	대부분의 프로그램에서 사용하는 기본 에러 코드
2	잘못된 사용법 (Misuse)	명령어 인자 오류 등
126	실행 불가 (Not Executable)	파일은 있으나 실행 권한 없음
127	명령어 없음 (Not Found)	실행 파일을 찾을 수 없음
128+N	시그널 N에 의한 종료	`kill -9` -> 종료 코드 137 (128+9)

  ┌────────────────────────────────────────────────────────────────────────┐
  │       부모 프로세스의 wait() 반환값 분석: 정상 vs 비정상 종료 구분     │
  ├────────────────────────────────────────────────────────────────────────┤
  │                                                                        │
  │  wait(&status) → status 변수 (int, 32비트)                             │
  │                                                                        │
  │  [정상 종료 시: WIFEXITED(status) == true]                             │
  │  ┌─────────────────────────────────┐                                   │
  │  │  status = (exit_code << 8)      │                                   │
  │  │                                 │                                   │
  │  │  예: exit(42) → status = 0x00002A00                                 │
  │  │  WEXITSTATUS(status) = 42      │                                    │
  │  └─────────────────────────────────┘                                   │
  │                                                                        │
  │  [비정상 종료 시: WIFSIGNALED(status) == true]                         │
  │  ┌─────────────────────────────────┐                                   │
  │  │  status = (signal_number)       │                                   │
  │  │                                 │                                   │
  │  │  예: SIGKILL(9) → status = 0x00000009                               │
  │  │  WTERMSIG(status) = 9          │                                    │
  │  └─────────────────────────────────┘                                   │
  │                                                                        │
  │  [부모의 판단 로직]                                                    │
  │  if (WIFEXITED(status)) {                                              │
  │      printf("정상 종료, 코드=%d\n", WEXITSTATUS(status));              │
  │  } else if (WIFSIGNALED(status)) {                                     │
  │      printf("시그널 %d로 비정상 종료\n", WTERMSIG(status));            │
  │  }                                                                     │
  └────────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] wait()의 status 변수는 정상 종료와 비정상 종료를 구분하는 인코딩을 사용한다. 정상 종료 시에는 종료 코드가 하위 8비트가 아닌 상위 8비트에 저장되어 WEXITSTATUS() 매크로로 추출하며, 비정상 종료 시에는 시그널 번호가 하위 7비트에 직접 저장된다. 이 구분은 부모 프로세스가 자식의 종료 원인을 정확히 파악하고 적절히 대응(예: 시그널 종료 시 자동 재시도)하기 위한 필수 정보다. 셸에서는 $? 변수를 통해 직전 명령어의 종료 코드를 확인할 수 있으며, echo $?가 137이면 128 + 9(SIGKILL)이므로 프로세스가 강제 종료되었음을 의미한다.

📢 섹션 요약 비유: 사망 진단서(wait status)에는 자연사(exit code)인지 사고사(signal)인지가 명확히 기록되며, 사고사의 경우 어떤 사고(시그널 번호)인지도 표시되어 가족(부모)이 원인을 파악하고 대응할 수 있게 합니다.

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

실무 시나리오

시나리오 -- 우아한 종료 (Graceful Shutdown) 설계: 전자상거래 플랫폼의 결제 서버가 배포(Deploy)를 위해 종료될 때, kill -9로 강제 종료하면 진행 중인 결제 트랜잭션이 중간에 끊겨 재고 불일치가 발생했다. 엔지니어는 쿠버네티스 (Kubernetes)의 preStop 훅과 SIGTERM 시그널 핸들러를 결합하여, 종료 요청 수신 후 (1) 새로운 요청 수신 중단, (2) 진행 중인 트랜잭션 완료 대기 (최대 30초), (3) 데이터베이스 커넥션 정상 반환, (4) exit(0) 호출의 네 단계 정리 프로세스를 구현하여 무중단 배포(Zero-downtime Deployment)를 달성했다.
시나리오 -- SIGKILL 남용의 참사: 개발자가 응답 없는 프로세스를 확인하고 즉시 kill -9를 습관적으로 사용한 결과, 해당 프로세스가 공유 메모리(Shared Memory)에 기록 중이던 실시간 센서 데이터가 버퍼 플러시 없이 유실되었다. 문제를 분석한 결과, SIGKILL은 사용자 수준 정리를 완전히 건너뛰므로, 반드시 먼저 kill -15(SIGTERM)로 정상 종료를 시도하고, 일정 시간 응답 없을 때만 SIGKILL을 사용하는 절차적 대응 매뉴얼을 도입했다.

도입 체크리스트

기술적: 모든 데몬 프로세스에 SIGTERM 시그널 핸들러가 등록되어 있는가? 핸들러에서 진행 중인 작업을 완료하고 자원을 정리한 후 exit(0)을 호출하는가?
운영적: kill -9 사용을 운영 가이드라인에서 제한하고, 프로세스 종료 시 반드시 SIGTERM -> 대기 -> SIGKILL 순서를 따르도록 규정했는가?

안티패턴

SIGKILL을 첫 번째 수단으로 사용: kill -9는 커널이 사용자 수준 정리를 건너뛰고 프로세스를 강제 종료하므로, 임시 파일, 공유 메모리, 데이터베이스 트랜잭션 등이 정리되지 않아 데이터 유실과 시스템 불일치를 초래한다. 반드시 SIGTERM을 먼저 시도해야 한다.
📢 섹션 요약 비유: 건물을 철거할 때 폭약(SIGKILL)부터 터뜨리면 건물 안의 귀중품(미처리 데이터)이 모두 파괴되지만, 먼저 사람들을 대피시키고 물건을 꺼낸 뒤에 철거(SIGTERM 후 exit)하면 아무런 손실이 없는 것과 같습니다.

Ⅴ. 기대효과 및 결론

정량/정성 기대효과

구분	종료 관리 미흡	체계적 종료 관리 (SIGTERM + cleanup)	개선 효과
정량	SIGKILL로 인한 데이터 유실 발생	모든 트랜잭션 정상 완료 후 종료	데이터 유실률 0%
정량	좀비 프로세스 누적으로 PID 고갈	wait()/init 수거로 PCB 즉시 해제	PID 낭비율 100% 제거
정성	비정상 종료 원인 불명	종료 코드로 원인 추적 가능	장애 대응 시간 대폭 단축

미래 전망

cgroup의 freeze 기능: 리눅스 커널의 cgroup v2는 프로세스를 종료하지 않고 일시 정지(freeze)하는 기능을 제공하여, 체크포인트/복원(Checkpoint/Restore) 기술과 결합되어 컨테이너의 라이브 마이그레이션(Live Migration)을 가능하게 하고 있다.
구조화된 종료 (Structured Concurrency): 최신 프로그래밍 언어(Java 21의 Virtual Thread, Go의 goroutine)는 프로세스 종료 시 하위 작업이 모두 정상 완료될 때까지 대기하는 구조화된 동시성 모델을 제공하여, 종료 관리의 복잡도를 언어 수준에서 추상화하고 있다.

참고 표준

POSIX.1: exit(), _exit(), wait(), waitpid() 시스템 콜 표준 및 종료 상태 인코딩 규격.
시그널 표준: POSIX 호환 시그널(SIGHUP, SIGINT, SIGQUIT, SIGKILL, SIGTERM, SIGSEGV 등)의 정의 및 기본 동작.

프로세스 종료는 단순한 소멸이 아니라, 자원 회수, 상태 전달, 부모-자식 동기화라는 세 가지 책임을 수행하는 정교하게 설계된 생명주기 이벤트다. 정상 종료와 비정상 종료의 차이를 이해하고, SIGTERM과 SIGKILL의 올바른 사용 순서를 준수하는 것은 시스템 안정성과 데이터 무결성을 보장하는 운영체제 관리의 핵심 역량이다.

📢 섹션 요약 비유: 프로세스의 삶과 죽음은 운영체제의 가장 중요한 관리 대상이며, 정상적인 죽음(exit)과 비정상적인 죽음(signal)을 구분하고, 죽은 후의 뒷정리(wait)까지 완벽하게 설계하는 것이 성숙한 시스템의 척도입니다.

개념 명칭	관계 및 시너지 설명
exit() 시스템 콜	프로세스가 스스로 정상 종료를 요청하는 표준 인터페이스로, 사용자 수준 정리와 커널 수준 정리를 순차적으로 수행한다.
wait() / waitpid()	부모가 자식의 종료 상태를 회수하여 좀비 프로세스를 해제하는 동기화 메커니즘이다.
시그널 (Signal)	SIGTERM, SIGKILL 등을 통해 프로세스에 비동기적으로 종료 요청을 전달하는 운영체제의 IPC 메커니즘이다.
좀비 프로세스 (Zombie Process)	종료 완료 후 부모가 wait()를 호출하지 않아 PCB가 잔존하는 상태로, 프로세스 종료의 불완전한 처리 결과다.
고아 프로세스 (Orphan Process)	부모가 자식보다 먼저 종료되어 init(PID 1)에 양자된 프로세스로, 종료 시 init이 수거한다.
Copy-on-Write (COW)	fork() 시 부모의 메모리를 공유하는 기법으로, exec()가 수행되면 공유 페이지가 전체 교체되어 종료와 밀접한 관계가 있다.

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

장난감 놀이를 마친 친구가 "끝났어!"라고 선생님(exit)에게 알리고 장난감을 제자리에 정리(자원 반환)하는 것이 정상 종료예요.
갑자기 비가 와서 친구가 장난감을 내팽개치고 도망가면(signal 종료) 선생님은 친구의 사물함(PCB)을 정리해 주고 부모님(wait)에게 연락해요.
가장 중요한 건 장난감을 정리하지 않고 도망가면(kill -9) 나중에 다른 친구들이 그 장난감을 못 쓰게 되니까, 항상 정리하고 나가야 한답니다!