Threads

Threads

스레드 (Thread) 는 하나의 프로세스 내에서 여러 실행 흐름을 동시에 수행할 수 있도록 하는 경량 실행 단위다.
자원을 공유하면서도 병렬로 처리할 수 있어 CPU 사용률을 극대화하며, 멀티코어 환경에서 반응성과 처리 성능 향상에 핵심적인 역할을 한다.
생성, 종료, 동기화, 스케줄링 등의 관리가 비교적 효율적이지만, 경쟁 상태, 데드락 등의 문제가 발생할 수 있어 주의가 필요하다.
웹 서버, 실시간 시스템, 데이터 처리 등 다양한 분야에서 쓰이며, 현대 소프트웨어에서 동시성과 병렬성을 구현하는 기반 기술로 활용된다.

등장 배경 및 발전 과정

등장 배경

초기 컴퓨터 시스템은 단일 실행 흐름 기반의 순차 처리 방식으로, 하나의 작업이 완료되어야 다음 작업이 수행되는 구조였다. 그러나 운영체제의 발전과 함께 동시성 처리의 필요성이 대두되면서, 멀티프로세싱 구조가 도입되었고, 프로세스 내에서도 독립적인 실행 흐름이 필요한 상황이 많아지며 스레드 (Thread) 개념이 등장하게 되었다.
또한, 멀티코어 CPU 의 확산, 입출력 지연의 병목 해소, 대용량 데이터 처리 등의 요구가 커지면서, 스레드는 자원 효율성과 응답성 확보를 위한 핵심 메커니즘으로 자리잡게 되었다.

발전 과정

목적 및 필요성

목적

필요성

핵심 개념

스레드 (Thread) 의 정의와 본질

스레드는 프로세스 내에서 실행되는 최소 실행 단위로, 각 스레드는 개별적인 스택 (Stack), 레지스터, 프로그램 카운터 (PC) 를 가지며, 프로세스의 코드, 데이터, 힙 등 메모리 공간은 공유한다.
이를 통해 스레드는 낮은 비용으로 병렬성 및 비동기 처리를 가능하게 한다.

스레드는 독립된 실행 흐름을 가지면서 자원을 공유하므로, 동기화 문제가 필연적으로 발생하며 이에 대한 해결이 필수적이다.

동시성 (Concurrency) vs. 병렬성 (Parallelism)

• 동시성: 여러 작업이 시간 분할 방식으로 실행되어 동시에 동작하는 것처럼 보이는 구조 (e.g., 싱글코어에서 인터리빙)
• 병렬성: 여러 작업이 실제로 동시에 실행되는 구조 (e.g., 멀티코어에서 여러 스레드 병렬 실행)

스레드 상태 모델

스레드는 다음과 같은 상태를 가지며, OS 스케줄러가 이 상태 전환을 관리한다:

• New: 생성된 초기 상태
• Runnable: 실행 준비 완료 상태 (스케줄 대기 중)
• Running: CPU 를 점유하고 실행 중
• Blocked/Waiting: 입출력 또는 동기화 대기 상태
• Terminated: 실행 종료

메모리 모델과 자원 공유

• 모든 스레드는 프로세스의 가상 메모리 공간 (코드/데이터/힙) 을 공유한다.
• 단, 스택 영역은 독립적으로 관리됨.
• 자원 공유는 효율을 높이지만, 경쟁 조건 (Race Condition), 데이터 불일치, 데드락 등의 동기화 문제가 수반됨.

사용자 수준 vs. 커널 수준 스레드

핵심 개념과 실무 구현 연관성

주요 기능 및 역할

스레드는 독립 실행 흐름, 공유 자원 접근, 스케줄링, 동기화 등 다양한 기능을 제공하며, 이를 기반으로 병렬 작업 처리, 자원 효율 향상, 사용자 반응성 강화 등의 역할을 수행한다.
특히 작업 분할, 백그라운드 처리, UI 블로킹 방지 등은 현대 애플리케이션의 성능과 사용자 경험에 직접적인 영향을 미친다.
또한 TLS, 우선순위 조정, 상태 전이 제어 등은 스레드 실행의 정밀한 제어를 가능하게 하여 확장성과 안정성을 동시에 확보하는 데 기여한다.

특징

• 구조적 특징: 스레드는 프로세스보다 훨씬 가볍고, 각자의 실행 컨텍스트를 유지하므로 빠른 전환과 높은 확장성을 제공한다.

• 자원 관리: 동일 프로세스 내 자원 공유 구조 덕분에 빠른 데이터 교환이 가능하지만, 그만큼 동기화에 신중해야 한다.

• 실행 특성: 스레드는 병렬성과 동시성을 모두 구현할 수 있으며, OS 의 스케줄링 정책에 따라 다양한 실행 흐름을 지원한다.

• 오류 처리: 하나의 스레드 오류가 전체 애플리케이션에 영향을 줄 수 있어 적절한 예외 처리와 복원 전략이 필요하다.

• 동기화 요구: 자원 공유 구조로 인해 동기화는 필수이며, 락 메커니즘 없이 안전한 실행은 불가능하다.

핵심 원칙

Threads 를 구현하거나 운용할 때 지켜야 할 핵심 원칙은 크게 세 가지 축으로 구분된다:

• 정확성 (Consistency)
• 안정성 (Safety)
• 효율성 (Efficiency).
  이들 원칙은 메모리 모델, 스케줄링 전략, 예외 처리 및 자원 분배까지 모든 레벨에서 적용된다.

• 정확성은 모든 병행 환경에서 필수적인 기반이다. 연산의 원자성, 변경의 가시성, 실행 순서의 예측 가능성은 병렬 처리의 일관성을 확보하기 위한 핵심 조건이다. 특히 멀티코어 환경에서는 메모리 일관성과 가시성 확보가 중요하다.

• 안정성은 시스템이 비정상 상황에서도 예측 가능한 상태를 유지하게 만든다. 공유 자원에 대한 경쟁을 제어하고, 데드락 및 예외 상황이 전체 애플리케이션을 중단시키지 않도록 설계해야 한다. 특히 웹 서버나 실시간 시스템 등에서는 장애 고립 설계가 중요하다.

• 효율성은 성능 극대화와 관련되며, 자원 경합 최소화, 실행 스케줄링의 효율화, 스레드 간 공정한 자원 분배 등이 포함된다. 락의 범위를 줄이거나 Thread Local Storage 를 활용하는 전략은 병목을 줄이고 확장성을 높인다.

주요 원리 및 작동 방식

• 스레드는 독립적인 실행 컨텍스트를 갖고 공유 메모리 구조 내에서 병렬적으로 동작하며, 이를 통해 고성능 처리와 응답성 향상이 가능하다.
• 스레드의 상태 전이는 스케줄러, 자원 접근, 동기화 메커니즘에 따라 정해지며, 다양한 스케줄링 정책이 이를 제어한다.
• 사용자 수준과 커널 수준 스레드는 성능, 병렬성, 제어 권한 측면에서 차이가 존재한다.

주요 원리 (스레드의 작동 개념과 스케줄링 원리)

1. 실행 컨텍스트 분리와 메모리 공유

   • 스레드는 독립적인 실행 컨텍스트 (PC, 레지스터, 스택) 를 갖는다.
   • 코드, 데이터, 힙 메모리는 모든 스레드가 공유하므로, 동시 접근에 대한 동기화가 필수이다.

2. 사용자/커널 수준 스레드

   • 사용자 수준 스레드 (ULT): 사용자 공간에서 생성/스케줄링. 빠르지만 한 스레드 블로킹 시 전체 블로킹.
   • 커널 수준 스레드 (KLT): 커널이 생성/관리. 병렬 실행 가능, 비용 높음.

3. 스레드 스케줄링 방식

작동 원리 (상태 전이 및 실행 구조)

스레드는 아래와 같은 상태 전이 흐름을 따른다:

stateDiagram-v2
    [*] --> New : 스레드 생성
    New --> Runnable : start() 호출
    Runnable --> Running : 스케줄러 선택
    Running --> Runnable : 타임슬라이스 종료
    Running --> Blocked : 락/IO 대기
    Running --> Waiting : wait(), join()
    Running --> Terminated : 작업 완료
    Blocked --> Runnable : 락 획득, I/O 완료
    Waiting --> Runnable : notify(), join 종료
    Terminated --> [*]

작동 구조 (스레드와 프로세스 간 구조도)

flowchart LR
    P[프로세스] --> T1[스레드 1]
    P --> T2[스레드 2]
    P --> T3[스레드 3]
    T1 --> S1[스택 1]
    T2 --> S2[스택 2]
    T3 --> S3[스택 3]
    P --> SHARED["공유 자원 (코드, 데이터, 힙)"]
    T1 --> SHARED
    T2 --> SHARED
    T3 --> SHARED

설명: 각 스레드는 자신의 실행 컨텍스트를 가지되, 프로세스의 공유 메모리 공간을 함께 사용한다.

구조 및 아키텍처

스레드는 프로세스 내에서 독립적인 실행 흐름을 가지며, Program Counter, Stack, Register Set, TCB 등의 필수 요소로 구성된다. 각 스레드는 고유한 스택과 실행 상태를 유지하며, 프로세스의 코드, 데이터, 힙 등을 공유한다. 또한, 필요에 따라 TLS를 통해 독립적인 전역 데이터를 사용할 수 있다.

flowchart TB
    subgraph Process["📦 Process (단일 주소 공간)"]
        direction TB
        Code["Code Segment (공유)"]
        Data["Data Segment (공유)"]
        Heap["Heap (공유)"]
        
        subgraph Thread1["🧵 Thread 1"]
            PC1[Program Counter]
            Reg1[Register Set]
            Stack1[Stack]
            TLS1[Thread Local Storage]
            TCB1[Thread Control Block]
        end
        
        subgraph Thread2["🧵 Thread 2"]
            PC2[Program Counter]
            Reg2[Register Set]
            Stack2[Stack]
            TLS2[Thread Local Storage]
            TCB2[Thread Control Block]
        end
        
        subgraph Thread3["🧵 Thread 3"]
            PC3[Program Counter]
            Reg3[Register Set]
            Stack3[Stack]
            TLS3[Thread Local Storage]
            TCB3[Thread Control Block]
        end
    end
    
    Scheduler[⚙️ Scheduler]
    Scheduler --> TCB1
    Scheduler --> TCB2
    Scheduler --> TCB3

    Heap --> Stack1
    Heap --> Stack2
    Heap --> Stack3

구성 요소

구현 기법 및 방법

사용자 수준 스레드 (ULT) - Python Asyncio

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import asyncio

async def worker(name):
    for i in range(3):
        print(f"{name} 실행 중 - 반복 {i+1}")
        await asyncio.sleep(1)  # Cooperative yield

async def main():
    tasks = [
        asyncio.create_task(worker("작업-1")),
        asyncio.create_task(worker("작업-2")),
        asyncio.create_task(worker("작업-3"))
    ]
    await asyncio.gather(*tasks)

# 이벤트 루프 실행
asyncio.run(main())

• async def 는 사용자 공간에서 실행 흐름을 정의.
• await asyncio.sleep() 은 명시적 CPU 양보이며, 이는 전형적인 Cooperative 스케줄링.
• 실제 커널 스레드는 1 개만 사용되고, 내부적으로는 경량 사용자 스레드처럼 작동함.

커널 수준 스레드 (KLT) 구현 예시 - Python threading 모듈

Python 의 threading.Thread 는 실제로 OS 커널 수준의 스레드 (KLT) 를 사용한다.

• CPython 은 native thread 사용

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import threading
import time

def worker(name):
    for i in range(3):
        print(f"{name} 실행 중 - 반복 {i+1}")
        time.sleep(1)  # 커널 수준의 sleep → 블로킹

threads = []
for i in range(3):
    t = threading.Thread(target=worker, args=(f"작업-{i+1}",))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

• threading.Thread 는 내부적으로 커널에 직접 등록되는 native thread를 사용함.
• time.sleep() 은 커널 단에서 스케줄링 블로킹 발생 → 해당 스레드는 OS 스케줄러가 직접 관리함.
• 각 스레드는 별도 커널 컨텍스트로 작동 → 멀티코어에서 진정한 병렬 실행 가능.
• 하나의 스레드가 블로킹되어도 나머지 스레드에는 영향 없음.

하이브리드 스레드 모델 (M:N) 구현 예시 - Go 의 Goroutine + GOMAXPROCS

Go 는 대표적인 M:N 스케줄링 기반 하이브리드 모델을 런타임 차원에서 제공한다.

• Go 언어 예시 (Goroutine: 수천 개의 사용자 스레드를 수 개의 커널 스레드에 매핑)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

func worker(name string, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 1; i <= 3; i++ {
        fmt.Printf("%s 실행 중 - 반복 %d\n", name, i)
        time.Sleep(1 * time.Second)
    }
}

func main() {
    runtime.GOMAXPROCS(2) // 최대 2개의 커널 스레드 사용 (N)

    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ { // M = 5
        wg.Add(1)
        go worker(fmt.Sprintf("작업-%d", i), &wg)
    }
    wg.Wait()
}

• go worker() 는 경량 사용자 스레드 (Goroutine) 를 생성함. (M)
• GOMAXPROCS(2) 는 런타임에 최대 2 개의 커널 수준 스레드 (N) 사용 지시.
• Go 런타임은 자체 스케줄러 (P-model: Processor, Machine, Goroutine) 를 통해 M:N 스케줄링 수행.
• 하나의 커널 스레드가 블로킹되면 다른 커널 스레드로 goroutine 을 이동시켜 실행 지속 → hybrid 구조.

장점

• 성능 최적화 측면에서 스레드는 프로세스보다 경량화되어 생성, 종료, 전환 비용이 적어 고빈도 작업 처리에 유리하다.

• 자원 효율성은 스레드들이 메모리와 파일 핸들 등을 공유함으로써 전체 자원 소모를 줄이는 데 기여하며, 동시에 컨텍스트 전환 시 비용도 절감된다.

• 반응성 향상은 UI 스레드와 백그라운드 스레드의 분리를 통해 사용자 경험을 저해하지 않고 비동기 작업을 처리할 수 있게 만든다.

• 확장성 및 병렬성은 스레드가 멀티코어 CPU 를 기반으로 병렬 작업을 분산 처리할 수 있게 하며, 스레드 풀 활용을 통해 서버 등에서 고부하 처리도 효과적으로 대응할 수 있다.

• 통신 및 구조 관리 측면에서는 스레드 간 데이터 교환이 매우 빠르고 간단하며, 이를 통해 코드의 모듈화와 유지보수성이 향상된다.

단점과 문제점 그리고 해결방안

단점 (구조적 또는 본질적 제약)

스레드는 본질적으로 자원을 공유하므로 동기화가 필수지만, 그로 인해 복잡성과 디버깅 어려움이 따라온다. 또한, 다량의 스레드가 생성되면 오버헤드가 발생하며, 메모리 관리나 우선순위 역전과 같은 구조적 문제가 수반될 수 있다. 이를 해결하려면 동기화 전략 강화, Thread Pool 운영, 우선순위 제어 등의 관리 기법이 요구된다.

문제점 (실행 중 발생하는 동작 문제)

스레드 운영 시 실시간으로 발생할 수 있는 문제들은 대부분 자원 경쟁과 스케줄링 불균형에서 기인한다. Race Condition 은 동기화 미비로 발생하며, Deadlock 은 락 충돌로 인한 전체 시스템 정지를 유발한다. Starvation 과 우선순위 역전은 스레드 간 불공정한 자원 분배로 연결되며, 종료 누락이나 과도한 CPU 사용은 시스템 성능을 저하시킬 수 있다. 이를 방지하기 위한 진단 도구, 스케줄링 전략, 동기화 제어가 실무에서 필수적이다.

도전 과제

• 동기화 성능 및 안정성은 병렬 환경에서의 핵심 과제로, 락 경합을 줄이고 원자성 있는 연산을 보장하는 구조 설계가 필요하다. 락리스 자료구조나 CAS 같은 저오버헤드 동기화 방식이 점점 중요해지고 있다.

• 메모리 모델 및 일관성 문제는 멀티코어와 멀티캐시 구조에서 발생하며, 예측 불가능한 버그와 데이터 오류를 유발할 수 있다. 이를 해결하기 위한 메모리 배리어와 원자 연산 도입은 필수다.

• 확장성 및 실행 오버헤드는 스레드가 많아질수록 컨텍스트 스위칭과 메모리 소모가 증가하면서 병목이 발생한다. 이벤트 기반, 코루틴, 액터 모델 등이 대안이 된다.

• 관찰 가능성 및 디버깅은 병렬성 증가로 인해 버그를 재현하고 원인을 분석하는 일이 복잡해졌으며, 이를 해결하기 위한 로그 상관 분석, 트레이싱 시스템, 시각화 도구가 필요하다.

• 자원 및 에너지 최적화는 고성능 시스템에서 스레드가 에너지 소모 및 발열에 미치는 영향을 최소화하는 방안으로, 적응형 스레드 풀과 에너지 인식 스케줄링이 요구된다.

• 스케일 아웃 한계는 단일 머신 내 스레드 수 증가가 구조적 한계에 도달하는 경우로, 이를 분산 시스템으로 전환하거나 멀티 프로세스 구조로 보완해야 한다.

• 에러 격리는 스레드 하나의 장애가 전체 프로세스에 영향을 미치지 않도록 스레드 수준에서 오류를 캡슐화하고 독립적인 오류 복구 메커니즘을 갖춰야 한다.

분류 기준에 따른 종류 및 유형

• 관리 주체: 스레드가 어디에서 관리되는지에 따라 ULT, KLT, 하이브리드로 나뉜다. 커널이 인식하는지 여부에 따라 병렬성 확보와 비용이 다르며, 하이브리드는 최근 트렌드다.

• 운영체제 지원 방식: 스레드와 커널 간의 매핑 방식은 성능, 병렬성, 확장성에 큰 영향을 미친다. 1:1 은 단순하고 병렬성 강력, M:N 은 확장성과 효율성 뛰어남.

• 실행 방식: 싱글 스레드는 단일 흐름 기반으로 간단하나 확장성이 부족하며, 멀티 스레드는 병렬 처리 가능하나 동기화 관리가 필요하다.

• 실행 성격: CPU 바운드는 계산 중심, I/O 바운드는 대기 중심 작업에 적합하며 스케줄링 전략이 달라진다. 실제 서버 구성 시 유형 분리가 중요하다.

• 생명주기: 사용자 스레드는 명시적 종료가 필요하며, 데몬 스레드는 백그라운드용으로 종속적이며 자동 종료된다.

• 우선순위: 스레드의 스케줄링 결정에 큰 영향을 주며, 실시간 시스템이나 QoS 가 필요한 환경에서 중요하게 작용한다.

실무 사용 예시

• 웹 및 서버 아키텍처에서는 클라이언트 요청을 동시에 처리하기 위해 스레드 풀과 논블로킹 I/O 가 결합된다. 이 구조는 서버 처리량 (throughput) 증가와 응답 시간 단축에 매우 효과적이며, 대규모 트래픽 환경에서 반드시 사용된다.

• 사용자 인터페이스 처리에서는 UI 스레드와 백그라운드 스레드를 분리함으로써, 사용자 입력과 백엔드 연산이 동시에 수행되도록 한다. 이는 앱 반응성 (Responsiveness) 을 유지하는 핵심 기법이다.

• 게임 및 실시간 엔진에서는 렌더링, 물리 연산, AI 등을 각각 별도 스레드로 분리하여 병렬 처리함으로써, 게임의 실시간성과 프레임률 안정성을 확보한다.

• 데이터 및 병렬 연산 처리는 대용량 데이터를 빠르게 처리하기 위한 핵심 구조다. 생산자 - 소비자 패턴, 병렬 큐 처리, OpenMP 등의 병렬 프레임워크는 연산 성능을 극대화하는 데 유용하다.

• 데이터베이스 및 저장소 처리는 스레드를 활용해 병렬 쿼리를 실행하거나 연결 수요를 분산시켜, 데이터베이스 서버의 확장성과 응답성을 높이는 데 기여한다.

• 멀티미디어 및 스트리밍 환경에서는 비디오/오디오 인코딩·디코딩에 병렬 구조가 반드시 필요하다. 스레드 기반의 디코딩 구조와 SIMD, GPU 병렬처리를 함께 사용하는 것이 일반적이다.

활용 사례

사례 1: 멀티스레드 기반 웹 서버

시나리오: 멀티스레드 기반 웹 서버에서 요청 처리 성능 최적화

시스템 구성:

• 클라이언트 → 리버스 프록시 (Nginx) → 멀티스레드 기반 WAS (예: Tomcat, FastAPI) → DB

graph TD
  A[Client] --> B[Nginx]
  B --> C[Web Application Server]
  C --> D[Thread Pool]
  D --> E[DB Connection Pool]

Workflow:

1. 클라이언트 요청 수신
2. WAS 의 Thread Pool 에서 스레드 할당
3. 요청 처리 및 DB 조회
4. 결과 반환

역할:

• Thread Pool: 동시 요청에 대한 처리 스레드 제공
• 각 스레드: 요청별 비즈니스 로직 실행
• DB Connection Pool: 스레드당 DB 연결 자원 제공

유무에 따른 차이점:

구현 예시: Python FastAPI + ThreadPoolExecutor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from fastapi import FastAPI
from concurrent.futures import ThreadPoolExecutor
import time

app = FastAPI()
executor = ThreadPoolExecutor(max_workers=10)

def background_task(delay: int):
    time.sleep(delay)
    return f"Completed after {delay} seconds"

@app.get("/process/")
async def run_in_thread(delay: int):
    future = executor.submit(background_task, delay)
    return {"message": "Processing in background", "status": "queued"}

사례 2: 이미지 처리 서비스에서 다중 스레드를 활용한 배치 처리 시스템

시나리오: 대용량 이미지 처리 서비스에서 다중 스레드를 활용한 배치 처리 시스템

시스템 구성:

• 메인 스레드: 작업 스케줄링 및 결과 수집
• 워커 스레드 풀: 이미지 변환 작업 처리
• I/O 스레드: 파일 읽기/쓰기 전담
• 모니터링 스레드: 시스템 상태 감시

graph TD
    Client[클라이언트 요청] --> MainThread[메인 스레드<br/>작업 스케줄링]
    MainThread --> TaskQueue[작업 큐<br/>Task Queue]
    
    TaskQueue --> WorkerPool[워커 스레드 풀<br/>Image Processing Workers]
    WorkerPool --> Worker1[워커 스레드 1]
    WorkerPool --> Worker2[워커 스레드 2]  
    WorkerPool --> WorkerN[워커 스레드 N]
    
    Worker1 --> IOThread[I/O 스레드<br/>File Operations]
    Worker2 --> IOThread
    WorkerN --> IOThread
    
    IOThread --> Storage[저장소<br/>File System]
    MainThread --> Monitor[모니터링 스레드<br/>System Monitor]
    Monitor --> Metrics[메트릭 수집<br/>Performance Data]

Workflow:

• 클라이언트 요청을 메인 스레드가 받아 작업 큐에 추가
• 워커 스레드들이 작업 큐에서 작업을 가져와 이미지 처리 수행
• I/O 스레드가 파일 읽기/쓰기 작업을 전담하여 워커 스레드 블로킹 방지
• 모니터링 스레드가 시스템 성능 지표를 지속적으로 수집

역할:

• 메인 스레드: 전체 시스템 조정 및 작업 분배
• 워커 스레드: CPU 집약적 이미지 처리 작업
• I/O 스레드: 디스크 I/O 최적화 및 버퍼링
• 모니터링 스레드: 성능 모니터링 및 이상 감지

유무에 따른 차이점:

• 스레드 사용 시: 멀티코어 활용으로 처리 시간 75% 단축, CPU 사용률 90% 이상
• 단일 스레드 시: 순차 처리로 인한 긴 처리 시간, CPU 코어 하나만 활용

구현 예시:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

import threading
import queue
import time
from PIL import Image
import os

class ImageProcessor:
    def __init__(self, num_workers=4):
        # 작업 큐와 결과 큐 초기화
        self.task_queue = queue.Queue()
        self.result_queue = queue.Queue()
        self.num_workers = num_workers
        self.workers = []
        self.io_thread = None
        self.monitor_thread = None
        self.processed_count = 0
        self.lock = threading.Lock()
        
    def worker_thread(self, worker_id):
        """워커 스레드: 이미지 처리 작업 수행"""
        while True:
            try:
                # 작업 큐에서 작업 가져오기 (타임아웃 설정)
                task = self.task_queue.get(timeout=1)
                if task is None:  # 종료 신호
                    break
                    
                # 이미지 처리 작업 수행
                input_path, output_path, operation = task
                self.process_image(input_path, output_path, operation)
                
                # 결과 큐에 완료 신호
                self.result_queue.put((worker_id, output_path, "완료"))
                
                # 처리 카운트 증가 (동기화)
                with self.lock:
                    self.processed_count += 1
                    
                self.task_queue.task_done()
                
            except queue.Empty:
                continue
            except Exception as e:
                self.result_queue.put((worker_id, None, f"오류: {e}"))
                
    def process_image(self, input_path, output_path, operation):
        """실제 이미지 처리 로직"""
        with Image.open(input_path) as img:
            if operation == "resize":
                # 이미지 크기 조정 (CPU 집약적 작업)
                processed = img.resize((800, 600), Image.Resampling.LANCZOS)
            elif operation == "rotate":
                # 이미지 회전
                processed = img.rotate(90, expand=True)
            else:
                processed = img
                
            # I/O 스레드에 저장 작업 위임
            self.save_image(processed, output_path)
            
    def save_image(self, image, output_path):
        """I/O 스레드를 통한 이미지 저장"""
        # 실제 구현에서는 별도 I/O 큐를 통해 처리
        image.save(output_path, "JPEG", quality=95)
        
    def monitor_thread_func(self):
        """모니터링 스레드: 시스템 상태 감시"""
        start_time = time.time()
        while True:
            time.sleep(5)  # 5초마다 상태 체크
            
            with self.lock:
                current_count = self.processed_count
                
            elapsed_time = time.time() - start_time
            rate = current_count / elapsed_time if elapsed_time > 0 else 0
            
            print(f"처리 현황: {current_count}개 완료, "
                  f"처리율: {rate:f}개/초, "
                  f"활성 스레드: {threading.active_count()}")
                  
            # 큐 상태 모니터링
            print(f"대기 작업: {self.task_queue.qsize()}, "
                  f"완료 작업: {self.result_queue.qsize()}")
                  
    def start_processing(self, image_tasks):
        """배치 처리 시작"""
        # 모니터링 스레드 시작
        self.monitor_thread = threading.Thread(
            target=self.monitor_thread_func, 
            daemon=True
        )
        self.monitor_thread.start()
        
        # 워커 스레드들 시작
        for i in range(self.num_workers):
            worker = threading.Thread(
                target=self.worker_thread, 
                args=(i,),
                name=f"Worker-{i}"
            )
            worker.start()
            self.workers.append(worker)
            
        # 작업들을 큐에 추가
        for task in image_tasks:
            self.task_queue.put(task)
            
        print(f"{len(image_tasks)}개 작업을 {self.num_workers}개 워커로 처리 시작")
        
    def wait_completion(self):
        """모든 작업 완료 대기"""
        # 모든 작업 완료 대기
        self.task_queue.join()
        
        # 워커 스레드들에 종료 신호
        for _ in self.workers:
            self.task_queue.put(None)
            
        # 모든 워커 스레드 종료 대기
        for worker in self.workers:
            worker.join()
            
        print(f"전체 {self.processed_count}개 이미지 처리 완료")

# 사용 예시
if __name__ == "__main__":
    # 처리할 이미지 작업 목록 생성
    tasks = [
        ("input1.jpg", "output1.jpg", "resize"),
        ("input2.jpg", "output2.jpg", "rotate"),
        ("input3.jpg", "output3.jpg", "resize"),
        # … 더 많은 작업들
    ]
    
    # 이미지 프로세서 생성 (4개 워커 스레드)
    processor = ImageProcessor(num_workers=4)
    
    # 배치 처리 시작
    processor.start_processing(tasks)
    
    # 완료 대기
    processor.wait_completion()

사례 3: 실시간 웹 서버 멀티스레딩 시스템 구성

시나리오: 실시간 웹 서버에서 수백만 동시 접속자를 처리하기 위해 스레드 풀 (Thread Pool) 기반의 멀티스레딩 시스템 구성

시스템 구성:

• 요청 수신기 (Listener)
• 스레드 풀 (Worker Thread Pool)
• 큐 (Queue)
• 응답 처리기 (Responder)
• 공유 자원 (공용 메모리, 데이터베이스 등)

flowchart LR
    Client(클라이언트)
    Listener(요청 수신기)
    Queue(요청 큐)
    ThreadPool(스레드 풀)
    Worker1(작업 스레드 1)
    Worker2(작업 스레드 2)
    WorkerN(작업 스레드 N)
    Responder(응답 처리기)
    DB(공유 자원/DB)

    Client --요청--> Listener
    Listener --큐에 요청 추가--> Queue
    Queue --할당--> ThreadPool
    ThreadPool --작업 분배--> Worker1
    ThreadPool --작업 분배--> Worker2
    ThreadPool --작업 분배--> WorkerN
    Worker1 --데이터 조회/갱신--> DB
    Worker2 --데이터 조회/갱신--> DB
    WorkerN --데이터 조회/갱신--> DB
    Worker1 --응답--> Responder
    Worker2 --응답--> Responder
    WorkerN --응답--> Responder
    Responder --응답 전달--> Client

Workflow:

• 클라이언트가 요청을 보냄
• 요청 수신기가 요청을 큐에 저장
• 스레드 풀에서 빈 작업자 스레드가 요청을 할당받아 처리
• 처리 후 응답 처리기가 결과를 전송

역할:

• 각 스레드가 개별적으로 처리, 전체 처리량 극대화, 자원 최적 공유

유무에 따른 차이점:

• 스레드 미적용 시: 각 요청마다 프로세스 생성, 자원 낭비, 스케일 확장 한계
• 스레드 적용 시: 효율적 자원 사용, 동시 요청 처리 확장성 극대화

구현 예시:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import threading
import queue

# 요청 처리 함수
def handle_request(request):
    result = f"처리: {request}"
    return result

# 워커 스레드 구현
def worker(q):
    while True:
        request = q.get()
        if request is None:
            break
        print(handle_request(request))
        q.task_done()

# 요청 큐 및 스레드풀 생성
request_queue = queue.Queue()
threads = []
for _ in range(5):  # 스레드 5개
    t = threading.Thread(target=worker, args=(request_queue,))
    t.start()
    threads.append(t)

# 요청 시뮬레이션
for req in range(20):
    request_queue.put(f"요청-{req}")

request_queue.join()  # 모든 요청 처리될 때까지 대기

# 워커 종료(종료 신호)
for _ in range(5):
    request_queue.put(None)
for t in threads:
    t.join()

실무에서 효과적으로 적용하기 위한 고려사항 및 주의할 점

• 스레드 수 및 생명주기 관리는 성능과 자원 효율성의 핵심으로, 스레드 풀의 적절한 크기 조정과 생명주기 통제가 매우 중요하다. 무한 생성은 오히려 시스템 부하를 증가시키므로 큐 기반 풀 구조를 추천한다.

• 동기화 및 자원 접근 제어는 병목과 데드락을 유발하는 주요 요인이며, 락의 범위를 좁히고 락프리 구조나 일관된 자원 획득 순서를 도입하는 것이 권장된다.

• 예외 처리 및 오류 대응은 스레드 수준에서 오류가 전체 시스템에 영향을 주지 않도록 캡슐화하는 것이 중요하다. 타임아웃과 재시도 정책을 포함한 복구 전략이 병행되어야 한다.

• 성능 최적화 및 하드웨어 고려는 스레드 간 전환을 최소화하고 CPU 캐시 친화적인 방식으로 데이터 접근을 설계해야 한다. 특히 NUMA 환경에서는 affinity 고려가 성능에 직접 영향을 준다.

• 디버깅 및 운영 가시성은 실시간 추적 및 문제 진단에 핵심적이다. 스레드별 로그 식별자 설정, 로깅 레벨 통제, APM 연동 등을 통해 운영 안정성을 높일 수 있다.

• 자원 회수 및 종료 처리는 시스템 안정성 보장의 마지막 단계다. 실행 중인 스레드를 정확히 종료하고, 미반환 자원을 수거하기 위한 종료 훅 및 shutdown API 호출이 필수다.

성능을 최적화하기 위한 고려사항 및 주의할 점

• 스레드 풀 및 작업 관리: 스레드 풀 크기, 작업 큐, 생성 오버헤드는 성능 최적화의 기본. 스레드는 남발하지 말고 재사용하고, 작업은 균등하게 분배해야 한다.

• 동기화 및 락 전략: 락은 성능을 갉아먹는 주범이 될 수 있다. 락 범위는 좁히고, 락 프리 구조나 atomic 연산으로 경쟁을 최소화하는 것이 바람직하다.

• 메모리 및 캐시 활용: 캐시 효율은 고성능의 핵심이다. 데이터는 캐시 라인에 맞게 배치하고, TLS 를 활용하여 공유를 최소화하며, False Sharing 을 방지하는 것이 중요하다.

• CPU 친화성 및 NUMA 고려: CPU 및 메모리 지역성 (Locality) 을 고려하면 캐시 히트율을 높이고 NUMA 환경에서 병목을 줄일 수 있다. CPU affinity 설정과 NUMA-aware 메모리 할당이 필요하다.

• 문맥 전환 및 비용 제어: 스레드 수가 많다고 좋은 게 아니다. 불필요한 컨텍스트 스위칭은 캐시 플러시와 오버헤드를 유발하며, 비동기 모델을 통해 효율적으로 자원을 사용해야 한다.

• 메모리 모델 및 일관성 보장: 병렬 실행 시 메모리 접근 순서나 가시성이 틀어지면 예측 불가능한 오류가 발생할 수 있다. 이를 방지하기 위해 메모리 배리어, volatile 변수, happens-before 관계 등을 설계에 반영해야 한다.

Thread 관련 현대 병행성 모델 비교, 병목 분석, Thread Pool 설계 전략

Thread 와 관련된 현대적 병행성 모델 비교 (Reactive, Actor 등)

모델 비교

graph TD
  subgraph Thread 모델
    T1[Thread 1] -->|공유 자원| R1[Resource]
    T2[Thread 2] --> R1
  end

  subgraph Reactive 모델
    E1[Event] --> H1[Handler 1]
    E2[Event] --> H2[Handler 2]
  end

  subgraph Actor 모델
    A1[Actor 1] -->|Message| A2[Actor 2]
    A2 -->|Message| A3[Actor 3]
  end

• Thread 기반은 직접적인 병렬성과 실행 흐름 제어가 가능하지만 복잡성과 동기화 문제가 따릅니다.
• Reactive 모델은 이벤트 기반으로 I/O 에 특화되어 있으며, 스레드 수 최소화, 고성능 웹 API 처리에 적합합니다.
• Actor 모델은 상태를 각 Actor 가 소유하고 메시지로 통신하기 때문에 분산 시스템, 대규모 병행 처리에 강력합니다.

Thread 기반 아키텍처에서 발생 가능한 병목 지점 식별과 해결 전략

Thread Pool 설계 시 고려사항 및 동적 튜닝 기법

Thread Pool 설계 고려사항

동적 튜닝 기법

Thread 관련 주요 API 설계 원칙

스레드를 사용하는 시스템을 설계하거나, Thread 기반 API 를 구성할 때 반드시 지켜야 할 설계 원칙들을 다음과 같이 정리합니다.

정리 및 학습 가이드

내용 정리

스레드는 현대 컴퓨터 시스템에서 동시성과 병렬성을 구현하기 위한 핵심 실행 단위다.

하나의 프로세스 내에서 여러 스레드가 메모리와 자원을 공유하면서 독립적으로 실행되어 자원 활용의 효율성을 극대화하고, 반응성 향상과 병렬 처리 성능 개선을 가능하게 한다.
운영체제에 따라 커널 수준 (KLT), 사용자 수준 (ULT), 하이브리드 모델로 구현되며, 메모리 구조, 스케줄링 전략, 동기화 기법, 예외 처리 등 설계 시 고려해야 할 요소가 많다.

실무에서는 웹 서버의 동시 요청 처리, 모바일 UI 비동기 처리, 게임 엔진의 물리 연산, 데이터 파이프라인의 병렬 처리 등에서 광범위하게 활용되며, 스레드 풀 기반의 자원 최적화가 일반적이다. 스레드는 단순한 실행 단위를 넘어서 전체 시스템의 성능과 안정성을 좌우하는 설계 핵심 요소다.

기술 동향 분석

최근 동시성 기술은 " 경량화 " 와 " 자동화 " 를 중심으로 빠르게 진화하고 있다.

대표적으로 Go 의 고루틴, Kotlin 의 코루틴, Java 의 Virtual Thread(Project Loom) 는 기존 스레드 모델의 한계를 극복하고, 수천~수만 개의 동시 실행 흐름을 보다 적은 자원으로 처리할 수 있게 한다.
또한 락프리 (Lock-Free) 알고리즘, 무상태 구조 (Stateless Design), CAS(Compare-And-Swap) 기반 동기화 방식이 널리 도입되며 성능 병목과 데드락 위험을 줄이고 있다.
클라우드 네이티브 환경에서는 서버리스 구조, 오토스케일링, 자원 할당 제한 등을 고려한 스레드 최적화가 필수 요소로 떠오르고 있다.
이와 함께 스레드 안전 (Thread-safe) 라이브러리, 비결정적 버그 디버깅을 위한 분산 추적 시스템, 실시간 메트릭 수집 및 로깅 시스템과의 통합도 중요해지고 있다.

결론적으로 스레드는 단순한 실행 단위가 아니라 아키텍처적 자산으로 설계되어야 하며, 동시성 기술은 지속적으로 고성능·고가용성·고관찰성을 추구하는 방향으로 발전하고 있다.

학습 항목 정리

용어 정리

참고 및 출처

• Thread in Operating System - GeeksforGeeks
• Threads and its Types in Operating System - GeeksforGeeks
• Thread (computing) - Wikipedia
• Java Virtual Threads vs Thread - Baeldung
• Java’s Virtual vs Platform Threads and What’s New in JDK 24 - Medium
• Virtual thread - Wikipedia
• POSIX Threads (pthreads) - Wikipedia
• How to Use Java 21’s Virtual Threads in Real‑World Web Applications - JavaCodeGeeks