[OS] Process와 Thread

🧩 Process

운영체제는 실행 중인 프로그램인 프로세스를 통해 하드웨어 자원을 관리합니다. 여러 프로세스가 동시에 구동되는 환경에서 각 프로세스는 CPU와 메모리를 독점적으로 사용하는 것처럼 동작하며, 운영체제는 이를 위한 격리된 실행 환경을 보장합니다. 프로세스는 단순히 실행 중인 상태를 넘어, 시스템 자원을 안전하게 공유하기 위한 가장 기본적인 격리 단위입니다.

메모리 격리와 주소 공간

프로세스 생성 시 운영체제는 해당 프로세스 전용의 가상 주소 공간을 할당합니다. 이 공간은 실행 코드가 담긴 Text, 전역 및 정적 변수가 위치한 Data, 동적 메모리 할당을 위한 Heap, 함수 호출과 지역 변수를 처리하는 Stack으로 구분됩니다.

이 설계의 목적은 프로세스 간의 독립성을 확보하는 데 있습니다. 프로세스는 다른 프로세스의 주소 공간에 직접 접근할 수 없으며, 허용되지 않은 메모리 영역을 침범할 경우 하드웨어(MMU)와 운영체제가 이를 차단합니다. 이때 발생하는 Segmentation Fault는 해당 프로세스를 즉시 종료시켜 시스템 전체의 안정성을 유지하는 역할을 합니다.

PCB의 정보와 역할

운영체제는 수많은 프로세스를 관리하기 위해 각 프로세스의 상태 정보를 기록한 PCB(Process Control Block)를 커널 메모리 영역에 생성합니다. PCB는 프로세스가 중단되었다가 다시 실행될 때 이전의 실행 상태를 완벽하게 복원하기 위한 데이터를 보관합니다.

PCB에는 프로세스 식별을 위한 PID, 현재 실행 상태(New, Ready, Running, Waiting, Terminated), 다음에 실행할 명령어 주소를 가리키는 Program Counter, 그리고 CPU 레지스터 값과 메모리 매핑 정보 등이 포함됩니다.

프로세스의 생명 주기와 fork()

유닉스 계열 시스템에서는 fork() 시스템 콜을 사용하여 부모 프로세스를 복제해 자식 프로세스를 생성합니다. 자식 프로세스는 부모의 PCB 정보와 메모리 상태를 상속받아 독립적인 실행 흐름을 갖게 됩니다.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
    pid_t pid;

    printf("fork() 호출 전. (부모 PID: %d)\n", getpid());

    // 새로운 프로세스 생성 (부모의 메모리 공간 복제)
    pid = fork();

    if (pid < 0) {
        // fork 실패
        fprintf(stderr, "fork failed\n");
        return 1;
    } else if (pid == 0) {
        // 자식 프로세스 코드 영역
        // 자식에게 fork의 반환값은 0입니다.
        printf("저는 자식 프로세스입니다. (PID: %d, 부모 PID: %d)\n", getpid(), getppid());
    } else {
        // 부모 프로세스 코드 영역
        // 부모에게 fork의 반환값은 생성된 자식의 PID입니다.
        printf("저는 부모 프로세스입니다. (PID: %d, 자식 PID: %d)\n", getpid(), pid);
    }

    // 부모와 자식 모두 이 코드를 실행하지만, 각자의 주소 공간에서 실행됩니다.
    printf("프로세스 종료. (PID: %d)\n", getpid());

    return 0;
}

프로세스 교체 과정

CPU 코어는 한 번에 하나의 명령어만 처리할 수 있지만, 운영체제는 프로세스를 매우 짧은 시간 단위로 교체하는 컨텍스트 스위칭을 통해 멀티태스킹을 구현합니다.

이 과정은 다음과 같은 순서로 진행됩니다.

1. 인터럽트가 발생하여 제어권이 커널 모드로 전환됩니다.
2. 현재 실행 중인 프로세스의 레지스터 상태를 해당 PCB에 저장합니다.
3. 스케줄러가 다음에 실행할 프로세스를 선택합니다.
4. 새로 선택된 프로세스의 PCB에서 레지스터 상태를 복원합니다.
5. 유저 모드로 전환하여 프로세스 실행을 재개합니다.

컨텍스트 스위칭은 멀티태스킹을 위한 필수적인 절차이지만, CPU가 실제 연산을 수행하지 못하는 순수 오버헤드 비용이기도 합니다.

🧩 Thread

스레드는 프로세스 내에서 실행되는 흐름의 단위입니다. 하나의 프로세스 안에서 여러 스레드가 동시에 작업을 수행하며, 프로세스에 할당된 메모리 중 힙 영역과 데이터 영역을 공유합니다. 이러한 자원 공유 덕분에 스레드는 프로세스보다 생성 비용이 저렴하며, 별도의 통신 과정 없이 공유 메모리를 직접 읽고 쓰는 방식으로 데이터를 교환할 수 있습니다.

자원 공유와 실행 흐름

스레드의 본질은 실행 흐름의 분리에 있습니다. 모든 스레드는 소속된 프로세스의 주소 공간을 공유하되, 각자가 코드를 실행한 위치와 연산 중인 임시 값은 독립적으로 관리해야 합니다.

스레드 간에 공유되는 자원과 격리되는 영역은 다음과 같이 구분됩니다.

• 공유 영역: 코드(Text), 전역 변수(Data), 동적 할당 메모리(Heap), 열린 파일 핸들 등 프로세스의 공용 자원.
• 격리 영역: 각 스레드만의 독립적인 스택과 레지스터 집합(PC 등).

이러한 구조 덕분에 스레드 간의 컨텍스트 스위칭은 프로세스 전환보다 비용이 적게 듭니다. 페이지 테이블을 교체할 필요 없이 CPU 레지스터 값만 변경하면 되기 때문입니다.

TCB와 전용 스택 할당

운영체제 스케줄링의 최소 단위는 스레드입니다. 커널은 스레드 관리를 위해 TCB(Thread Control Block)라는 데이터 구조를 유지하며, 여기에는 스레드의 실행 상태, CPU 레지스터 값, 스택 포인터 등이 기록됩니다.

스레드가 생성될 때 운영체제는 해당 스레드 전용 스택을 프로세스의 주소 공간 내에 할당합니다. 이 공간은 함수 호출 시 발생하는 지역 변수와 복귀 주소를 저장하며, 스레드 간의 실행 흐름이 섞이지 않도록 보장하는 역할을 합니다.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// 모든 스레드가 공유하는 전역 변수 (Data 영역)
int shared_counter = 0;

// 스레드가 실행할 함수
void *thread_function(void *arg) {
    char *thread_name = (char *)arg;
    int i;
    // 각 스레드는 자신만의 스택에 지역 변수 i를 가집니다.
    for (i = 0; i < 1000000; i++) {
        // 공유 변수에 동시 접근 (경쟁 상태 발생 가능)
        shared_counter++;
    }
    printf("%s 작업 완료.\n", thread_name);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    // 두 개의 스레드 생성
    // 각 스레드는 thread_function을 실행하며, 동일한 shared_counter를 공유합니다.
    pthread_create(&thread1, NULL, thread_function, "Thread 1");
    pthread_create(&thread2, NULL, thread_function, "Thread 2");

    // 스레드가 종료될 때까지 대기 (메인 스레드 블로킹)
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 결과 출력 (동기화가 없다면 2000000이 아닐 수 있음)
    printf("최종 카운터 값: %d\n", shared_counter);

    return 0;
}

데이터 충돌과 동기화

자원을 공유한다는 특징은 데이터 정합성 문제로 이어집니다. 여러 스레드가 하나의 자원에 동시에 접근하여 값을 수정할 때 경쟁 상태(Race Condition)가 발생하기 때문입니다.

고부하 시스템에서 한 스레드가 공유 변수를 수정하는 도중에 컨텍스트 스위칭이 일어나 다른 스레드가 해당 값을 변경해버리면 논리적인 오류가 발생합니다. 따라서 멀티스레드 환경에서는 데이터의 일관성을 유지하기 위한 동기화 처리가 필수적입니다.

잠금 장치와 병렬성 저하

스레드 안전성(Thread Safety)을 확보하기 위해 뮤텍스나 세마포어 같은 잠금 장치를 사용하면 병렬성이 저하될 수 있습니다. 특정 자원을 사용하기 위해 스레드들이 대기 상태에 머물게 되면서 처리량이 급감하는 잠금 경합(Lock Contention) 현상이 발생하기 때문입니다.

결국 효율적인 멀티스레딩의 핵심은 단순히 스레드 개수를 늘리는 것이 아니라, 공유 자원을 최소화하고 동기화 비용을 줄이는 설계에 있습니다.

Cache Pollution

컨텍스트 스위칭의 비용은 레지스터 저장과 복원뿐만 아니라 캐시 오염에서도 발생합니다. 프로세스가 교체된 직후 하드웨어 캐시의 효율이 급격히 떨어지는 현상을 의미합니다.

캐시 데이터 무효화

CPU는 램의 속도 한계를 극복하기 위해 L1, L2, L3 캐시 구조를 가집니다. 프로세스 실행 중에는 참조 국소성 원리에 따라 자주 사용하는 데이터와 명령어가 캐시에 적재됩니다.

하지만 컨텍스트 스위칭이 일어나면 새로운 프로세스가 기존 프로세스의 데이터를 밀어내고 자신의 데이터를 채우기 시작합니다. 이 과정에서 기존 프로세스가 구축해둔 워킹 셋이 유실됩니다. 가상 메모리 기법으로 데이터 복사 비용은 줄일 수 있지만, 물리적인 캐시 점유 상태까지 보존할 수는 없습니다.

교체 직후의 속도 하락

캐시 오염은 프로세스 재실행 시 캐시 미스의 증가로 이어집니다. CPU가 데이터를 찾기 위해 상대적으로 느린 램에 접근해야 하므로 연산 속도가 저하됩니다.

특히 고부하 환경에서는 다음과 같은 요인이 성능에 영향을 줍니다.

• TLB Flush: 주소 변환 정보를 담은 TLB가 스위칭 시점에 무효화되거나 교체되어 메모리 접근 효율이 떨어집니다.
• 상태 복구 비용: 캐시 히트율이 정상 궤도에 오르기까지 걸리는 콜드 캐시 구간에서 시스템 레이턴시가 발생합니다.

과도한 스레드 생성이 위험한 이유

CPU 코어 수보다 스레드를 과하게 생성하면 컨텍스트 스위칭 빈도가 높아져 캐시 오염이 상시화됩니다. 이는 실제 연산보다 캐시를 교체하는 작업에 자원이 낭비되는 결과를 초래합니다.

Copy-on-Write

fork() 시스템 콜 호출 시 운영체제가 부모 프로세스의 메모리 공간 전체를 즉시 복사하면 상당한 자원과 시간이 소모됩니다. 운영체제는 이를 효율적으로 처리하기 위해 쓰기 시 복사(이하 COW)라는 지연 복사 전략을 사용합니다.

fork와 지연 복사 전략

COW는 실제 수정이 발생하기 전까지 메모리 복사를 미루는 방식입니다. fork()가 실행되면 운영체제는 물리 메모리를 복사하지 않고 부모 프로세스의 페이지 테이블만 복제합니다.

이 시점에 부모와 자식 프로세스는 동일한 물리 메모리 페이지를 공유하게 됩니다. 이 방식 덕분에 프로세스의 메모리 크기와 관계없이 생성 작업이 빠르게 완료됩니다.

데이터 수정과 실제 복사

프로세스 간 격리를 유지하기 위해 운영체제는 공유 중인 모든 페이지를 읽기 전용으로 설정합니다. 이후 특정 프로세스가 데이터를 수정하려고 시도할 때 실제 복사가 일어납니다.

1. 페이지 폴트 발생: 읽기 전용 페이지에 쓰기를 시도하면 하드웨어가 예외를 발생시킵니다.
2. 커널 개입: 운영체제가 해당 페이지의 COW 설정을 확인합니다.
3. 지연된 복사: 쓰기를 시도한 시점에 해당 페이지만 물리 메모리의 새로운 영역으로 복사합니다.
4. 페이지 테이블 업데이트: 복사된 새로운 물리 주소를 가리키도록 테이블을 수정하고 권한을 읽기/쓰기로 변경합니다.

Redis의 중단 없는 스냅샷

Redis는 BGSAVE 명령 시 fork()를 호출하여 자식 프로세스를 생성합니다. COW를 활용하면 서비스 중단 없이 자식 프로세스가 생성 시점의 메모리 상태를 스냅샷으로 유지하며 디스크에 저장할 수 있습니다.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    // 초기 데이터를 가진 변수
    int data = 100;
    pid_t pid;

    printf("fork() 전: data = %d, 주소 = %p\n", data, &data);

    pid = fork();

    if (pid < 0) {
        fprintf(stderr, "fork error\n");
        return 1;
    } else if (pid == 0) {
        // [자식 프로세스]
        // 이 시점까지는 COW에 의해 부모와 동일한 물리 페이지를 공유합니다.
        printf("[자식] 쓰기 전: data = %d, 주소 = %p (부모와 가상 주소 동일)\n", data, &data);
        
        // 자식 프로세스가 값을 수정하는 순간, 페이지 복사(COW)가 발생합니다.
        data = 200;
        printf("[자식] 쓰기 후: data = %d, 주소 = %p (값 변경됨, 새로운 물리 페이지)\n", data, &data);
    } else {
        // [부모 프로세스]
        // 자식이 종료될 때까지 대기하여 출력이 섞이지 않게 합니다.
        wait(NULL); 
        // 부모의 데이터는 자식의 수정에 영향을 받지 않습니다 (격리 보장).
        printf("[부모] 자식 종료 후: data = %d, 주소 = %p (값 유지됨)\n", data, &data);
    }

    return 0;
}

M:N Scheduling

운영체제가 관리하는 커널 스레드는 생성 시 약 1MB의 스택 메모리가 할당되며, 컨텍스트 스위칭마다 커널 모드 진입이 필요하여 비용이 높습니다. 대규모 동시 접속을 처리하는 시스템에서 접속자마다 커널 스레드를 할당하는 방식은 자원 부족 문제를 야기할 수 있습니다. 이를 해결하기 위해 유저 레벨 스레드와 커널 스레드를 효율적으로 매핑하는 M:N 스케줄링이 도입되었습니다.

스레드 매핑 방식

스레드 모델은 기술적 요구에 따라 세 가지 방식으로 구분됩니다.

1. 1:1 모델: 유저 스레드 하나가 커널 스레드 하나에 직접 매핑되는 구조입니다. 자바의 전통적인 버전이나 C++에서 사용하며, 멀티코어 활용에 유리하지만 생성과 스위칭 비용이 큽니다.
2. N:1 모델: 여러 유저 스레드가 하나의 커널 스레드 위에서 동작합니다. 컨텍스트 스위칭은 빠르지만, 하나의 스레드에서 블로킹 시스템 콜이 발생하면 해당 커널 스레드에 속한 모든 유저 스레드가 중단되는 문제가 있습니다.
3. M:N 모델: 다수의 유저 스레드를 상대적으로 적은 수의 커널 스레드에 동적으로 할당합니다. Go 언어의 고루틴이나 자바 21의 가상 스레드가 이 방식을 따릅니다.

M:N 모델에서는 운영체제가 아닌 언어의 런타임 스케줄러가 유저 스레드를 관리하며, 어떤 커널 스레드에 작업을 올릴지 결정합니다.

런타임 작업 분배

M:N 모델의 핵심 알고리즘 중 하나는 워크 스틸링(Work Stealing)입니다. 특정 커널 스레드가 자신에게 할당된 작업을 모두 처리하면 다른 스레드의 작업 큐에서 태스크를 가져와 처리함으로써 CPU 가동률을 극대화합니다.

이러한 방식은 메모리 효율성도 높습니다. 고루틴은 수 KB의 메모리로 시작하여 필요에 따라 스택 크기를 동적으로 조절합니다. 자바 21의 가상 스레드 또한 블로킹 I/O 발생 시 커널 스레드를 점유하지 않고 양보(Yield)하는 메커니즘을 통해 수많은 실행 흐름을 동시에 처리할 수 있게 합니다.

M:N 모델의 모니터링 비용

M:N 모델은 성능 효율이 높지만, 에러 발생 시 추적이 복잡하다는 단점이 있습니다. 유저 스레드에서 발생한 문제가 어느 커널 스레드 문맥에서 실행되었는지 파악하기 위해 별도의 모니터링 도구가 필요할 수 있습니다.

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.Executors;
import java.util.stream.IntStream;

public class VirtualThreadDemo {
    public static void main(String[] args) {
        // 10만 개의 동시 작업 수행. 기존 플랫폼 스레드(1:1 모델)로는 메모리 부족(OOM)이 발생할 수 있는 규모입니다.
        int numTasks = 100_000;

        System.out.printf("%d개의 가상 스레드 작업 생성을 시작합니다...\n", numTasks);
        Instant start = Instant.now();

        // Executors.newVirtualThreadPerTaskExecutor()는 각 작업마다 새로운 가상 스레드를 생성합니다.
        // try-with-resources 구문을 사용하면 블록을 빠져나갈 때 executor.close()가 호출되어
        // 제출된 모든 작업이 완료될 때까지 메인 스레드가 대기합니다 (Structured Concurrency).
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            IntStream.range(0, numTasks).forEach(i -> {
                executor.submit(() -> {
                    try {
                        // 각 스레드는 I/O 작업을 시뮬레이션하기 위해 잠시 대기합니다.
                        // 가상 스레드는 블로킹 시 캐리어 스레드(커널 스레드)를 점유하지 않고 '양보(Yield)'합니다.
                        Thread.sleep(Duration.ofMillis(100));
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                });
            });
        } // 여기서 모든 가상 스레드의 작업이 끝날 때까지 기다립니다.

        Instant end = Instant.now();
        System.out.printf("모든 작업이 완료되었습니다. 소요 시간: %d ms\n", Duration.between(start, end).toMillis());
        // 결과적으로 소수의 커널 스레드만으로 10만 개의 논리적 실행 흐름을 효율적으로 처리해냅니다.
    }
}

Summary

현대 컴퓨팅 구조는 프로세스의 격리와 스레드의 자원 공유 사이의 균형을 맞추는 과정입니다. 운영체제는 가상 주소 공간과 PCB를 통해 시스템 안정성을 확보하며, 쓰기 시 복사와 M:N 스케줄링을 통해 하드웨어 자원을 효율적으로 활용합니다. 그러나 컨텍스트 스위칭으로 인한 캐시 오염과 멀티스레드 환경의 잠금 경합 문제는 여전히 해결해야 할 과제로 남아 있습니다. 따라서 서비스의 부하 특성에 맞는 적절한 실행 모델을 선택하는 설계 능력이 중요합니다.

References

• [PlanetScale] Processes and Threads
• [OSTEP] Operating Systems: Three Easy Pieces
• [AWS Builders’ Library] Timeouts, retries and backoff with jitter