7장: Free-threaded Python - GIL 제거의 시작

스레드 A                     스레드 B
-----------                  -----------
obj.refcount = 1             obj.refcount = 1
                             
x = obj  (refcount++ -> 2)   y = obj  (refcount++ -> ???)
                             
# 두 스레드가 동시에 refcount를 증가시키면
# 2가 아닌 다른 값이 될 수 있음 (경쟁 조건)

import threading
import time
 
def cpu_bound(n: int) -> int:
    """CPU 집약적 작업"""
    total = 0
    for i in range(n):
        total += i * i
    return total
 
N = 50_000_000
 
# 순차 실행
start = time.time()
cpu_bound(N)
cpu_bound(N)
sequential_time = time.time() - start
 
# 멀티스레드 실행 (GIL 있음)
start = time.time()
t1 = threading.Thread(target=cpu_bound, args=(N,))
t2 = threading.Thread(target=cpu_bound, args=(N,))
t1.start()
t2.start()
t1.join()
t2.join()
threaded_time = time.time() - start
 
print("Sequential: " + str(round(sequential_time, 2)) + "s")
print("Threaded:   " + str(round(threaded_time, 2)) + "s")
# GIL이 있으면 threaded_time >= sequential_time

1. 기존 코드 호환성 유지
   - GIL 활성 빌드가 기본
   - free-threaded 빌드는 별도 실행 파일
 
2. 단일 스레드 성능 최소 저하
   - 목표: 5% 이내 오버헤드
   - 실측: 1~8% (플랫폼에 따라 다름)
 
3. 점진적 전환
   - C 확장 라이브러리의 호환성 경로 제공
   - 라이브러리가 준비되면 free-threaded 지원 선언

1. Biased Reference Counting
   - 객체를 생성한 스레드(소유 스레드)는 빠른 경로 사용
   - 다른 스레드는 원자적 연산으로 참조 카운팅
   - 대부분의 객체는 생성 스레드에서 사용되므로 오버헤드 최소
 
2. Deferred Reference Counting
   - 지역 변수 같은 단기 참조는 카운팅을 지연
   - 가비지 컬렉션 시점에 일괄 처리
 
3. Immortal Objects (PEP 683)
   - None, True, False 등은 참조 카운팅 자체를 하지 않음
   - 6장에서 다룬 내용
 
4. Per-object Locks
   - 객체별 세밀한 잠금으로 동시 접근 제어
   - dict, list 등 컨테이너 객체에 적용

# 공식 설치 프로그램 사용 시 "Free-threaded" 옵션 체크
# 설치 후 별도 실행 파일 생성
python3.13t  # free-threaded 빌드
 
# 또는 소스에서 빌드
./configure --disable-gil
make
make install

# uv를 사용하면 더 간편함
uv python install 3.13t
uv run --python 3.13t script.py

# 공식 설치 프로그램에서 "Customize installation" 선택
# "Free-threaded binaries" 옵션 체크
# 설치 후: python3.13t.exe

import sys
 
# GIL 상태 확인
print(sys._is_gil_enabled())
# False -> free-threaded 모드
# True  -> GIL 활성 모드

import threading
import time
import sys
 
def compute_sum(start: int, end: int, results: list, index: int) -> None:
    """지정된 범위의 제곱합을 계산"""
    total = 0
    for i in range(start, end):
        total += i * i
    results[index] = total
 
def run_sequential(n: int, num_chunks: int) -> float:
    chunk_size = n // num_chunks
    results = [0] * num_chunks
    start_time = time.time()
    for i in range(num_chunks):
        start = i * chunk_size
        end = start + chunk_size
        compute_sum(start, end, results, i)
    return time.time() - start_time
 
def run_threaded(n: int, num_threads: int) -> float:
    chunk_size = n // num_threads
    results = [0] * num_threads
    threads = []
    start_time = time.time()
    for i in range(num_threads):
        start = i * chunk_size
        end = start + chunk_size
        t = threading.Thread(
            target=compute_sum, args=(start, end, results, i)
        )
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    return time.time() - start_time
 
N = 50_000_000
NUM_THREADS = 4
 
seq_time = run_sequential(N, NUM_THREADS)
thr_time = run_threaded(N, NUM_THREADS)
 
print("GIL enabled: " + str(sys._is_gil_enabled()))
print("Sequential: " + str(round(seq_time, 3)) + "s")
print("Threaded (" + str(NUM_THREADS) + "): " + str(round(thr_time, 3)) + "s")
print("Speedup: " + str(round(seq_time / thr_time, 2)) + "x")

# GIL 활성 빌드 (python3.13)
GIL enabled: True
Sequential: 4.521s
Threaded (4): 4.892s
Speedup: 0.92x  # GIL로 인해 오히려 느림
 
# Free-threaded 빌드 (python3.13t)
GIL enabled: False
Sequential: 4.873s  # 단일 스레드에서 약간의 오버헤드
Threaded (4): 1.384s
Speedup: 3.52x  # 거의 4배 가까운 병렬화

CPU 바운드 작업:
  GIL 빌드:    멀티스레딩 효과 없음
  Free-threaded: 코어 수에 비례하는 속도 향상
 
I/O 바운드 작업:
  GIL 빌드:    멀티스레딩 효과 있음 (GIL이 I/O 중 해제)
  Free-threaded: 동일한 효과 + 약간의 추가 개선
 
혼합 작업:
  GIL 빌드:    I/O 부분만 병렬화
  Free-threaded: CPU + I/O 모두 병렬화

완전 지원:
  - NumPy 2.1+
  - Cython 3.1+
  - pydantic 2.x
 
부분 지원 / 진행 중:
  - pandas
  - scikit-learn
  - matplotlib
 
미지원:
  - 일부 소규모 C 확장 라이브러리

import importlib.metadata
 
def check_free_threading_support(package_name: str) -> None:
    """패키지의 free-threading 지원 여부 확인"""
    try:
        meta = importlib.metadata.metadata(package_name)
        classifiers = meta.get_all("Classifier") or []
        for c in classifiers:
            if "Free-Threading" in c or "free-threading" in c:
                print(package_name + ": free-threading supported")
                return
        print(package_name + ": no free-threading classifier found")
    except importlib.metadata.PackageNotFoundError:
        print(package_name + ": not installed")

import threading
 
# 안전하지 않음: 공유 리스트에 동시 접근
shared_list = []
 
def unsafe_append(items: list[int]) -> None:
    for item in items:
        shared_list.append(item)  # 경쟁 조건 가능
 
# 안전함: Lock 사용
lock = threading.Lock()
 
def safe_append(items: list[int]) -> None:
    for item in items:
        with lock:
            shared_list.append(item)

import threading
 
# Lock: 기본적인 상호 배제
lock = threading.Lock()
 
# RLock: 재진입 가능 Lock (같은 스레드가 여러 번 획득 가능)
rlock = threading.RLock()
 
# Semaphore: 동시 접근 수 제한
semaphore = threading.Semaphore(value=3)  # 최대 3개 스레드 동시 접근
 
# Event: 스레드 간 신호 전달
event = threading.Event()
 
# Barrier: 여러 스레드가 동시에 특정 지점에 도달할 때까지 대기
barrier = threading.Barrier(parties=4)

Free-threaded (threading):
  장점:
  - 메모리 공유 (프로세스 간 직렬화 불필요)
  - 프로세스 생성 오버헤드 없음
  - 공유 데이터 구조에 대한 빠른 접근
  단점:
  - 스레드 안전성을 직접 관리해야 함
  - 실험적 기능 (Python 3.13)
 
multiprocessing:
  장점:
  - 완전한 격리 (한 프로세스 충돌이 다른 프로세스에 영향 없음)
  - 오래되고 안정적인 API
  단점:
  - 프로세스 간 데이터 전송 비용 (직렬화/역직렬화)
  - 높은 메모리 사용량 (각 프로세스가 독립적 메모리 공간)
  - 프로세스 생성 오버헤드

Python 3.13 (2024) - 실험적 도입, 별도 빌드
Python 3.14 (2025) - 안정화, 더 많은 라이브러리 지원
Python 3.15 (2026) - 기본 빌드에 포함 가능성 검토
Python 3.16+ (2027~) - GIL 없는 빌드가 기본이 될 가능성