Brain프로세스와 스레드 (Process & Thread)
핵심 인사이트 (3줄 요약)
프로세스(Process): 실행 중인 프로그램으로, 독립된 메모리 공간(Code, Data, Heap, Stack)을 가지는 작업 단위 스레드(Thread): 프로세스 내에서 실행되는 실행 흐름의 최소 단위, 같은 프로세스의 스레드들은 메모리 공유 핵심 차이: 생성 비용(프로세스 높음/스레드 낮음), 통신 방식(IPC vs 직접 접근), 격리 수준(완전 격리 vs 메모리 공유)
Ⅰ. 개요
개념:
- 프로세스(Process): 보조기억장치에 저장된 프로그램이 메모리에 적재되어 실행 중인 상태. 운영체제로부터 독립된 메모리 공간을 할당받으며, 최소 하나의 스레드(메인 스레드)를 포함한다.
- 스레드(Thread): 프로세스 내에서 실제로 실행되는 흐름의 최소 단위. 같은 프로세스에 속한 스레드들은 코드, 데이터, 힙 영역을 공유하고, 각자 스택과 레지스터만 별도로 가진다.
💡 비유: "공장과 작업자" — 프로세스는 공장(자원, 설비, 건물), 스레드는 작업자(실제로 일하는 사람). 한 공장에 작업자가 여러 명일 수 있고, 작업자들은 공장 설비를 함께 사용한다.
등장 배경 (필수: 3가지):
- CPU 활용 효율 향상: 단일 프로그램 실행 시 I/O 대기 시간에 CPU가 놀게 됨 → 여러 프로그램을 동시에 실행하여 CPU 유휴 시간 감소
- 사용자 응답성 개선: 한 프로그램이 응답하지 않아도 다른 프로그램은 계속 실행 가능 → 멀티태스킹 지원
- 자원 공유와 경제성: 프로세스는 생성 비용이 비싸므로, 같은 작업을 여러 흐름으로 나누어 처리하기 위해 스레드 도입
핵심 목적: CPU라는 한정된 자원을 효율적으로 분배하여, 여러 작업을 동시에 수행하는 것처럼 보이게 함(동시성, Concurrency)
Ⅱ. 구성 요소 및 핵심 원리
1. 프로세스 메모리 구조
┌─────────────────────────────────────────────────────────────────────────┐
│ 프로세스 메모리 구조 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 📚 Code Segment (코드 영역) │ │
│ │ • 실행 가능한 기계어 코드 │ │
│ │ • Read-Only (읽기 전용) │ │
│ │ • 모든 스레드가 공유 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ ↑ 공유 │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 📊 Data Segment (데이터 영역) │ │
│ │ • 전역 변수, 정적 변수 (static) │ │
│ │ • 초기화된 데이터(.data) + 초기화 안 된 데이터(.bss) │ │
│ │ • Read-Write (읽기/쓰기 가능) │ │
│ │ • 모든 스레드가 공유 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ ↑ 공유 │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 🏠 Heap (힙 영역) │ │
│ │ • 동적 메모리 할당 (malloc, new) │ │
│ │ • 런타임에 크기 결정 │ │
│ │ • 아래에서 위로 성장 │ │
│ │ • 모든 스레드가 공유 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ ↑ 공유 │
│ ┌──────────────┬──────────────┬──────────────┐ │
│ │ 🧵 Thread 1 │ 🧵 Thread 2 │ 🧵 Thread 3 │ ← 스레드별 독립 │
│ │ Stack │ Stack │ Stack │ │
│ │ (지역변수) │ (지역변수) │ (지역변수) │ │
│ │ (함수 호출) │ (함수 호출) │ (함수 호출) │ │
│ │ ↑ │ ↑ │ ↑ │ │
│ │ Registers │ Registers │ Registers │ ← PC, SP 등 │
│ └──────────────┴──────────────┴──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
2. PCB (Process Control Block, 프로세스 제어 블록)
┌─────────────────────────────────────────────────────────────────────────┐
│ PCB (Process Control Block) │
│ "운영체제가 프로세스를 관리하기 위한 메타데이터" │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 🔢 PID (Process ID) │ │
│ │ • 프로세스 고유 식별자 │ │
│ │ • ps, top 명령어로 확인 가능 │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 📊 Process State (프로세스 상태) │ │
│ │ • New, Ready, Running, Waiting, Terminated │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 📍 Program Counter (PC) │ │
│ │ • 다음에 실행할 명령어의 주소 │ │
│ │ • Context Switch 시 저장/복원 │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 📦 CPU Registers │ │
│ │ • Accumulator, Index Register, Stack Pointer 등 │ │
│ │ • Context Switch 시 저장/복원 │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 💾 Memory Management Info │ │
│ │ • Page Table Base, Limit Register │ │
│ │ • 메모리 할당 정보 │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 📁 I/O Status Info │ │
│ │ • 열린 파일 목록, 할당된 I/O 장치 │ │
│ │ • 파일 디스크립터 테이블 │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 📈 Scheduling Info │ │
│ │ • Priority, Scheduling Queue Pointers │ │
│ │ • CPU 사용 시간, 대기 시간 │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
3. 프로세스 상태 전이 다이어그램
┌──────────────────────────────────────────────────────┐
│ │
┌──────────────────────────┼──────────────────────────────────────────────────┐ │
│ │ │ │
│ ┌────────────┐ │ ┌────────────┐ ┌────────────┐ │ │
│ │ New │ ────────┼─→ │ Ready │ ←────── │ Waiting │ │ │
│ │ (생성) │ │ │ (준비) │ │ (대기) │ │ │
│ └────────────┘ │ └──────┬─────┘ └──────↑─────┘ │ │
│ │ │ │ │ │
│ │ │ Dispatcher │ I/O 완료 │ │
│ │ ↓ (스케줄링) │ Timer │ │
│ │ ┌────────────┐ │ │ │
│ │ │ Running │ ───────────────┘ │ │
│ │ │ (실행) │ │ │
│ │ └──────┬─────┘ │ │
│ │ │ │ │
│ │ │ Exit │ │
│ │ ↓ │ │
│ │ ┌────────────┐ │ │
│ │ │ Terminated │ │ │
│ │ │ (종료) │ │ │
│ │ └────────────┘ │ │
│ │ │ │
└──────────────────────────┴──────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────┐│
│ │ 상태 전이 트리거: ││
│ │ • New → Ready: 프로세스 생성 완료 ││
│ │ • Ready → Running: CPU 스케줄러가 선택 ││
│ │ • Running → Ready: Time Quantum 만료 (RR) ││
│ │ • Running → Waiting: I/O 요청, 이벤트 대기 ││
│ │ • Waiting → Ready: I/O 완료, 이벤트 발생 ││
│ │ • Running → Terminated: 프로세스 종료 ││
│ └─────────────────────────────────────────────────┘│
│ │
└──────────────────────────────────────────────────────┘
4. 컨텍스트 스위칭 (Context Switching)
┌─────────────────────────────────────────────────────────────────────────────┐
│ 컨텍스트 스위칭 (Context Switch) │
│ "CPU를 한 프로세스에서 다른 프로세스로 넘겨주는 과정" │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 시간 → │
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ Process A 실행 │ │
│ │ ┌──────────┐ │ │
│ │ │ Code │ │ │
│ │ ├──────────┤ ┌──────────────────────────────────────────┐ │ │
│ │ │ Data │ │ Context Switch │ │ │
│ │ ├──────────┤ │ ┌─────────────────────────────────────┐ │ │ │
│ │ │ Heap │ │ │ 1. Process A의 PCB에 레지스터 저장 │ │ │ │
│ │ └──────────┘ │ │ 2. Process B의 PCB에서 레지스터 복원 │ │ │ │
│ │ │ │ 3. 페이지 테이블 교체 (TLB flush) │ │ │ │
│ │ CPU Registers: │ │ 4. 캐시 적중률 저하 (Cold Cache) │ │ │ │
│ │ PC=0x1000 │ └─────────────────────────────────────┘ │ │ │
│ │ SP=0x7FFF │ ↓ │ │ │
│ │ │ 오버헤드 (약 1~10μs) │ │ │
│ └────────────────────┴──────────────────────────────────────────┘ │ │
│ ↓ │ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ Process B 실행 │ │
│ │ ┌──────────┐ │ │
│ │ │ Code │ │ │
│ │ ├──────────┤ │ │
│ │ │ Data │ │ │
│ │ ├──────────┤ │ │
│ │ │ Heap │ │ │
│ │ └──────────┘ │ │
│ │ │ │
│ │ CPU Registers: │ │
│ │ PC=0x2000 │ │
│ │ SP=0x8FFF │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ ⚠️ 컨텍스트 스위칭 비용: │
│ • 직접 비용: 레지스터 저장/복원 (약 1μs) │
│ • 간접 비용: 캐시 미스, TLB 미스, 파이프라인 플러시 (약 10~100μs) │
│ • 스레드 컨텍스트 스위칭이 프로세스보다 약 10배 빠름 (메모리 공유로 인해) │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
5. 멀티프로세스 vs 멀티스레드 비교
| 구분 | 멀티프로세스 | 멀티스레드 |
|---|---|---|
| 메모리 구조 | 각 프로세스가 독립된 메모리 공간 | 같은 프로세스 내 스레드가 메모리 공유 |
| 생성 비용 | 높음 (fork 시 전체 메모리 복사) | 낮음 (스택만 새로 할당) |
| 컨텍스트 스위칭 | 느림 (TLB flush, 캐시 초기화) | 빠름 (공유 메모리로 캐시 효과 유지) |
| 통신 방식 | IPC (파이프, 소켓, 공유메모리) | 직접 접근 (전역 변수, 힙) |
| 안정성 | 높음 (한 프로세스 장애가 다른 프로세스에 영향 없음) | 낮음 (한 스레드 장애가 전체 프로세스에 영향) |
| 동기화 | 필요 없음 (독립적) | 필수 (뮤텍스, 세마포어) |
| 예시 | Chrome 탭, Apache Prefork | Chrome 렌더러, Java Thread |
6. 코드 예시: 멀티프로세스 vs 멀티스레드 (Python)
import os
import threading
import multiprocessing
import time
# ============================================
# 멀티프로세스 예시 (독립된 메모리 공간)
# ============================================
def worker_process(counter_name, iterations):
"""각 프로세스는 독립된 메모리 공간을 가짐"""
local_count = 0
for i in range(iterations):
local_count += 1
print(f"[Process {os.getpid()}] {counter_name}: {local_count}")
def run_multiprocess():
print("=== 멀티프로세스 실행 ===")
processes = []
for i in range(4):
p = multiprocessing.Process(
target=worker_process,
args=(f"Counter-{i}", 1000000)
)
processes.append(p)
p.start()
for p in processes:
p.join() # 모든 프로세스 종료 대기
# ============================================
# 멀티스레드 예시 (메모리 공유)
# ============================================
shared_counter = 0
lock = threading.Lock() # 동기화를 위한 락
def worker_thread(counter_name, iterations):
"""스레드는 전역 변수를 공유 → 동기화 필요"""
global shared_counter
for i in range(iterations):
with lock: # 락 획득 (동시 접근 방지)
shared_counter += 1
print(f"[Thread] {counter_name}: 완료")
def run_multithread():
print("=== 멀티스레드 실행 ===")
threads = []
for i in range(4):
t = threading.Thread(
target=worker_thread,
args=(f"Thread-{i}", 1000000)
)
threads.append(t)
t.start()
for t in threads:
t.join() # 모든 스레드 종료 대기
print(f"최종 공유 카운터: {shared_counter}")
# ============================================
# 성능 비교
# ============================================
if __name__ == "__main__":
start = time.time()
run_multiprocess()
print(f"멀티프로세스 소요 시간: {time.time() - start:.3f}초\n")
start = time.time()
run_multithread()
print(f"멀티스레드 소요 시간: {time.time() - start:.3f}초")
Ⅲ. 기술 비교 분석
1. 장단점 분석
멀티프로세스 장단점:
| 장점 | 단점 |
|---|---|
| 높은 격리성: 한 프로세스 장애가 다른 프로세스에 영향 없음 | 높은 생성 비용: fork() 시 메모리 전체 복사 |
| 보안성: 메모리가 격리되어 데이터 유출 위험 낮음 | IPC 오버헤드: 프로세스 간 통신 비용 높음 |
| CPU 친화적: 멀티코어 활용에 유리 | 컨텍스트 스위칭 비용: TLB flush, 캐시 미스 |
멀티스레드 장단점:
| 장점 | 단점 |
|---|---|
| 낮은 생성 비용: 스택만 새로 할당 | 동기화 복잡성: 락, 데드락, 레이스 컨디션 |
| 빠른 통신: 메모리 공유로 직접 접근 | 안정성 문제: 한 스레드 오류가 전체 프로세스 영향 |
| 효율적 컨텍스트 스위칭: 캐시 효과 유지 | 디버깅 어려움: 비결정적 동작 |
2. CPU 스케줄링 알고리즘 비교
| 알고리즘 | 원리 | 장점 | 단점 | 사용 환경 |
|---|---|---|---|---|
| FCFS (First Come First Served) | 도착 순서대로 실행 | 구현 단순 | Convoy Effect (긴 작업 뒤에 짧은 작업 대기) | Batch 시스템 |
| SJF (Shortest Job First) | 실행 시간이 짧은 작업 우선 | 평균 대기 시간 최소 | 실행 시간 예측 어려움, 기아 현상 | Batch 시스템 |
| RR (Round Robin) | Time Quantum 만큼만 실행 후 교체 | 공정함, 응답성 좋음 | Time Quantum 설정에 따른 성능 편차 | 시분할 시스템 |
| Priority | 우선순위가 높은 작업 우선 | 중요 작업 우선 처리 | 기아(Starvation) 현상 | Real-time 시스템 |
| MLQ (Multi-Level Queue) | 우선순위별로 큐 분리 | 다양한 작업 유형 처리 | 큐 간 이동 불가, 우선순위 설정 복잡 | 대학 서버 |
| MLFQ (Multi-Level Feedback Queue) | MLQ + 피드백 (큐 간 이동 가능) | 동적 우선순위 조정 | 파라미터 설정 복잡 | Unix/Linux |
★ 선택 기준: 실시간 시스템은 Priority/EDF, 일반 서버는 MLFQ, 데스크톱은 RR 변형(CFS) 사용
Ⅳ. 실무 적용 방안
1. 기술사적 판단: 적용 시나리오
| 적용 분야 | 권장 아키텍처 | 이유 | 기대 효과 |
|---|---|---|---|
| 웹 브라우저 | 멀티프로세스 | 탭 간 격리로 안정성 확보 | 한 탭 장애 시 다른 탭 영향 없음 |
| 웹 서버 | 멀티스레드 + 이벤트 루프 | 높은 동시성, 낮은 메모리 사용 | TPS 10만 건 이상 처리 |
| 데이터베이스 | 멀티프로세스 + 멀티스레드 | 격리성 + 병렬 처리 | 트랜잭션 ACID 보장 |
| 게임 서버 | 멀티스레드 | 실시간 통신, 낮은 지연 | 응답 시간 10ms 이내 |
| AI/ML 추론 | 멀티프로세스 (Python GIL 우회) | CPU 병렬 활용 | 처리량 4배 향상 (4코어) |
2. 실제 도입 사례
- 사례 1: Google Chrome — 각 탭을 별도 프로세스로 실행, 한 탭 크래시 시 다른 탭 보호. 2024년 기준 평균 30~40개 프로세스 실행
- 사례 2: Nginx — 마스터 프로세스 + 워커 프로세스(멀티프로세스) + 각 워커 내 이벤트 루프(단일 스레드). C10K 문제 해결
- 사례 3: Redis — 단일 스레드 이벤트 루프로 높은 성능 달성. 초당 100,000+ 요청 처리 (락 오버헤드 없음)
- 사례 4: Apache HTTPD — Prefork(멀티프로세스)와 Worker(멀티스레드) 선택 가능. Prefork는 안정성, Worker는 성능 중시
3. 도입 시 고려사항
-
기술적 고려:
- GIL (Global Interpreter Lock): Python은 스레드가 CPU 작업 병렬화 불가 → 멀티프로세스 사용
- CPU 바운드 vs I/O 바운드: CPU 바운드는 멀티프로세스, I/O 바운드는 멀티스레드/비동기
- 코어 수: 4코어 이하면 스레드 우선, 16코어 이상이면 프로세스도 고려
-
운영적 고려:
- 모니터링: 프로세스/스레드 수, CPU 사용률, 컨텍스트 스위칭 빈도
- 장애 대응: 프로세스는 재시작으로 복구, 스레드는 전체 프로세스 재시작 필요
- 리소스 제한: ulimit, cgroup으로 프로세스/스레드 수 제한
-
보안적 고려:
- 메모리 격리: 민감 데이터는 별도 프로세스로 분리
- 권한 분리: 최소 권한 원칙으로 각 프로세스에 서로 다른 권한 부여
- 샌드박싱: 외부 코드 실행 시 격리된 프로세스에서 수행
-
경제적 고려:
- 메모리 비용: 프로세스당 수십 MB ~ 수백 MB 할당
- CPU 오버헤드: 컨텍스트 스위칭 비용 고려
4. 주의사항 / 흔한 실수
- ❌ GIL 무시: Python에서 CPU 바운드 작업에 멀티스레드 사용 → 실제로는 싱글코어만 사용
- ❌ 락 없이 공유 변수 접근: 레이스 컨디션 발생 → 데이터 손상
- ❌ 무한정 스레드 생성: 스레드 풀(ThreadPool) 사용 권장
- ❌ 데드락 미대비: 락 획득 순서 일관성 유지, 타임아웃 설정
5. 관련 개념 / 확장 학습
📌 프로세스/스레드 핵심 연관 개념 맵
┌─────────────────────────────────────────────────────────────────────────────┐
│ 프로세스 & 스레드 관계도 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ 스케줄링 │ │ 동기화 │ │
│ │ (Scheduling) │ │(Synchronization)│ │
│ └──────┬───────┘ └──────┬───────┘ │
│ │ │ │
│ ↓ ↓ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 프로세스 & 스레드 (Process & Thread) │ │
│ │ "실행 단위의 계층 구조" │ │
│ └───────────────────────────┬──────────────────────────────────┘ │
│ │ │
│ ┌──────────────────────┼──────────────────────┐ │
│ ↓ ↓ ↓ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ Context │ │ PCB │ │ IPC │ │
│ │ Switch │ │ (프로세스 제어) │ │ (프로세스 통신)│ │
│ └───────┬───────┘ └───────┬───────┘ └───────┬───────┘ │
│ │ │ │ │
│ ↓ ↓ ↓ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ Deadlock │ │ 가상 메모리 │ │ 파일 시스템 │ │
│ │ (교착상태) │ │ (Virtual Mem) │ │ (File System) │ │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
| 관련 개념 | 관계 | 설명 | 문서 링크 |
|---|---|---|---|
| CPU 스케줄링 | 실행 제어 | 프로세스/스레드에 CPU 할당 | [CPU 스케줄링](./cpu_scheduling.md) |
| 동기화 (Synchronization) | 필수 기법 | 스레드 간 순서 보장, 락 | [동기화](./synchronization.md) |
| 교착상태 (Deadlock) | 발생 문제 | 락 대기 사이클 | [교착상태](./deadlock.md) |
| 컨텍스트 스위칭 | 실행 메커니즘 | CPU 제어권 이양 | 본문 참조 |
| PCB (Process Control Block) | 메타데이터 | 프로세스 정보 저장 | 본문 참조 |
| IPC (Inter-Process Communication) | 통신 방법 | 프로세스 간 데이터 교환 | [IPC](./ipc.md) |
| 가상 메모리 | 메모리 관리 | 각 프로세스에 독립 주소 공간 | [가상 메모리](../01_computer_architecture/virtual_memory.md) |
| Thread Pool | 최적화 패턴 | 스레드 재사용으로 생성 비용 절감 | 디자인 패턴 |
| Fork/Exec | 생성 시스템콜 | 프로세스 생성 및 실행 | [프로세스 생성](./process_creation.md) |
🔗 심화 학습 경로:
- 기본: 프로세스/스레드 → PCB → 컨텍스트 스위칭
- 심화: 동기화 → 데드락 → 스케줄링
- 확장: 멀티프로세싱 → 분산 시스템 → 컨테이너
Ⅴ. 기대 효과 및 결론
정량적 기대 효과
| 효과 영역 | 구체적 내용 | 정량적 목표 |
|---|---|---|
| 시스템 처리량 | 멀티코어 활용으로 병렬 처리 | Throughput 4배 향상 (4코어) |
| 응답 시간 | 적절한 스케줄링으로 대기 시간 단축 | 응답 시간 50% 감소 |
| 안정성 | 프로세스 격리로 장애 전파 방지 | 서비스 가용성 99.99% |
| 자원 효율 | 스레드 활용으로 메모리 절약 | 메모리 사용량 30% 감소 |
미래 전망
-
기술 발전 방향:
- M:N 스레딩: 사용자 스레드와 커널 스레드를 다대다 매핑 (Go의 Goroutine)
- 그린 스레드: 사용자 공간 스레드로 컨텍스트 스위칭 비용 절감
- 비대칭 멀티프로세싱: 성능/전력 효율을 위한 이종 코어 활용 (ARM big.LITTLE)
-
시장 트렌드:
- 클라우드 네이티브: 컨테이너(프로세스 격리) + 스레드(내부 병렬성) 하이브리드
- 서버리스: 함수 단위 실행으로 프로세스/스레드 관리 추상화
-
후속 기술:
- User-Level Threading: 커널 개입 없이 스레드 관리 (빠른 컨텍스트 스위칭)
- Coroutines/Fibers: 협력적 멀티태스킹 (Go, Kotlin, Rust async)
결론: 프로세스와 스레드는 운영체제의 가장 기본적인 실행 단위로, 격리성(프로세스)과 효율성(스레드) 사이의 트레이드오프를 이해하고 상황에 맞게 선택하는 것이 기술사의 핵심 역량이다. 현대 시스템은 두 모델을 혼합하여 사용하며, 클라우드/컨테이너 환경에서도 이 원칙은 동일하다.
※ 참고 표준: POSIX (IEEE 1003.1), Linux Kernel Documentation, Windows Internals, APUE (Advanced Programming in the UNIX Environment)
어린이를 위한 종합 설명
프로세스와 스레드는 "컴퓨터가 일하는 방식"을 나타내는 말이에요.
비유: 공장과 작업자
컴퓨터를 공장이라고 생각해 볼까요?
┌────────────────────────────────────────────────────────────────────┐
│ 컴퓨터라는 공장 │
│ │
│ 🏭 프로세스 1 (게임 공장) │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ 🧵 작업자1: 그래픽 담당 │ │
│ │ 🧵 작업자2: 소리 담당 │ │
│ │ 🧵 작업자3: 키보드 입력 담당 │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │
│ 🏭 프로세스 2 (인터넷 공장) │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ 🧵 작업자1: 웹페이지 불러오기 │ │
│ │ 🧵 작업자2: 동영상 재생 │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘
1. 프로세스가 뭐예요?
프로세스는 "하나의 공장"이에요.
- 공장에는 건물, 설비, 창고가 있죠? 이게 메모리예요
- 공장마다 서로 다른 물건을 만들어요 (게임, 인터넷, 음악...)
- 공장끼리는 서로 침범할 수 없어요 (안전!)
2. 스레드가 뭐예요?
스레드는 "공장 안의 작업자"예요.
- 한 공장에 작업자가 여러 명일 수 있어요
- 작업자들은 같은 설비를 함께 써요 (메모리 공유)
- 작업자가 많으면 일이 더 빨리 끝나요!
3. 왜 구분해요?
| 구분 | 프로세스 (공장) | 스레드 (작업자) |
|---|---|---|
| 독립성 | 완전히 독립 | 같은 공장 안에서 일함 |
| 통신 | 전화/이메일로 연락 | 옆에서 바로 말함 |
| 안전성 | 한 공장이 망해도 다른 공장은 OK | 한 작업자 실수하면 공장 전체가 위험 |
4. 요약
- 프로세스 = 독립된 공장 (안전하지만 비용이 많이 들어요)
- 스레드 = 공장 안의 작업자 (빠르지만 조심해야 해요)
컴퓨터는 여러 공장(프로세스)을 돌리면서, 각 공장 안에서 여러 작업자(스레드)가 일하게 만들어서 효율적으로 일해요! 🏭👷