Orc’s WIKI

Orc Hwang

Introduction
Python의 GIL(Global Interpreter Lock)은 CPython 인터프리터의 핵심 메커니즘 중 하나로, 멀티스레딩 환경에서 Python 코드의 실행을 제어합니다. GIL은 Python의 성능과 동시성 처리에 큰 영향을 미치며, Python 개발자라면 반드시 이해해야 할 개념입니다.
GIL 작동 원리
GIL이란?
GIL(Global Interpreter Lock)은 한 번에 하나의 스레드만 Python 바이트코드를 실행할 수 있도록 보장하는 뮤텍스(mutex)입니다. 즉, 멀티스레드 환경에서도 실제로는 한 시점에 하나의 스레드만 Python 코드를 실행할 수 있습니다.
왜 GIL이 필요한가?
메모리 관리의 단순화: CPython은 reference counting 방식으로 메모리를 관리합니다. GIL이 없다면 여러 스레드가 동시에 객체의 reference count를 수정할 때 race condition이 발생할 수 있습니다.
C 확장 모듈과의 호환성: 많은 C 확장 모듈들이 GIL의 존재를 전제로 설계되었습니다.
구현의 단순성: GIL을 사용하면 인터프리터 구현이 훨씬 단순해집니다.
GIL의 동작 방식
import threading
import time
counter = 0
def increment():
    global counter
    for _ in range(1000000):
        counter += 1
# 멀티스레드 실행
threads = []
start_time = time.time()
for _ in range(2):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()
for thread in threads:
    thread.join()
print(f"Counter: {counter}")
print(f"Time: {time.time() - start_time:.2f}s")
위 코드에서 두 스레드가 동시에 실행되지만, GIL로 인해 실제로는 순차적으로 실행됩니다.
Thread vs Process vs Async
Python에서 동시성을 처리하는 세 가지 주요 방법을 비교해보겠습니다.
Threading (멀티스레딩)
특징:
하나의 프로세스 내에서 여러 스레드 생성
메모리 공유로 인한 낮은 오버헤드
GIL로 인해 CPU-bound 작업에서는 성능 향상이 없음
I/O-bound 작업에 적합
적합한 경우:
네트워크 요청
파일 I/O
데이터베이스 쿼리
import threading
import requests
def fetch_url(url):
    response = requests.get(url)
    print(f"Fetched {url}: {len(response.content)} bytes")
urls = ["https://example.com" for _ in range(5)]
threads = [threading.Thread(target=fetch_url, args=(url,)) for url in urls]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()
Multiprocessing (멀티프로세싱)
특징:
독립적인 Python 인터프리터 프로세스 생성
각 프로세스가 자체 GIL을 가지므로 진정한 병렬 처리 가능
높은 메모리 오버헤드
CPU-bound 작업에 적합
적합한 경우:
이미지/비디오 처리
데이터 분석
수학적 계산
import multiprocessing
import time
def cpu_intensive_task(n):
    count = 0
    for i in range(n):
        count += i ** 2
    return count
if __name__ == "__main__":
    start_time = time.time()
    with multiprocessing.Pool(processes=4) as pool:
        results = pool.map(cpu_intensive_task, [10000000] * 4)
    print(f"Results: {len(results)}")
    print(f"Time: {time.time() - start_time:.2f}s")
Async/Await (비동기 프로그래밍)
특징:
단일 스레드에서 이벤트 루프 기반 동작
GIL의 영향을 받지만, I/O 대기 중에 다른 작업 수행 가능
낮은 메모리 오버헤드
많은 수의 I/O-bound 작업에 최적
적합한 경우:
웹 스크래핑
API 서버
웹소켓 통신
import asyncio
import aiohttp
async def fetch_url(session, url):
    async with session.get(url) as response:
        content = await response.read()
        print(f"Fetched {url}: {len(content)} bytes")
async def main():
    urls = ["https://example.com" for _ in range(5)]
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        await asyncio.gather(*tasks)
asyncio.run(main())
비교 표
방식
      GIL 영향
      CPU-bound
      I/O-bound
      메모리
      복잡도
    
Threading
      높음
      ❌
      ✅
      낮음
      낮음
    
Multiprocessing
      없음
      ✅
      ⚠️
      높음
      중간
    
Async
      있음
      ❌
      ✅
      매우 낮음
      높음
    
PyPy, nogil 프로젝트 동향
PyPy
PyPy는 JIT(Just-In-Time) 컴파일러를 사용하는 대안 Python 구현체입니다.
특징:
CPython보다 평균 4.5배 빠른 성능
여전히 GIL을 가지고 있음
STM(Software Transactional Memory) 기반 GIL-free 버전 실험 중
현재 상태 (2025):
PyPy 3.10 버전까지 지원
대부분의 주요 라이브러리와 호환
프로덕션 환경에서 안정적으로 사용 가능
# PyPy 설치 및 사용
pypy3 -m pip install numpy
pypy3 my_script.py
PEP 703 & PEP 779: Free-Threaded Python
Free-threaded Python은 CPython에서 GIL을 제거하여 진정한 병렬 처리를 가능하게 하는 공식 프로젝트입니다.
주요 마일스톤:
Sam Gross가 제안한 GIL 제거 방안 (PEP 703)
2024년 PEP 703 승인됨
Python 3.13 (2024.10): 실험적 기능으로 포함
Python 3.14 (2025.10.07): PEP 779 승인으로 공식 지원 시작
    
“실험적” 태그 제거
Production-ready 상태로 승격
바이너리 휠, CI 이미지, 호스팅 플랫폼의 1급 시민 지원
기술적 접근:
Biased Reference Counting: 효율적인 참조 카운팅
Deferred Reference Counting: 지연된 참조 카운팅
Immortal Objects: 불변 객체의 최적화
PEP 659 적용 (3.14): Specializing adaptive interpreter가 free-threaded 모드에서 활성화
메모리 관리 개선: 약 10% 메모리 사용량 증가 (성능 향상의 트레이드오프)
빌드 및 설치:
# 방법 1: uv를 사용한 간편 설치 (권장)
uvx python@3.14t  # 't' suffix는 free-threaded 빌드를 의미
# 방법 2: 소스에서 빌드
./configure --disable-gil
make
./python
# Python 코드에서 GIL 상태 확인
import sys
print(sys._is_gil_enabled())  # False
Windows에서 확장 모듈 컴파일 시 주의사항 (3.14+):
# build backend에서 Py_GIL_DISABLED 전처리 변수를 명시적으로 지정해야 함
import sysconfig
print(sysconfig.get_config_var('Py_GIL_DISABLED'))
성능 영향:
단일 스레드: 약 5-10% 성능 저하 (3.13의 10-15%에서 크게 개선)
멀티 스레드: CPU-bound 작업에서 선형적 성능 향상
    
Python 3.14: 약 3.1x 속도 향상 (vs 3.13의 2.2x)
Fibonacci 테스트 (4 threads): 5배 빠름 (279ms vs 1377ms)
Counter 테스트 (2 threads): 1.4배 빠름 (27.21s vs 37.35s)
DataFrame 연산: 50-90% 처리 시간 단축
마이그레이션 로드맵:
✅ Python 3.13 (2024.10): 실험적 free-threaded 빌드 도입
✅ Python 3.14 (2025.10): 공식 지원 시작 (PEP 779 승인)
    
단일 스레드 성능 페널티 5-10%로 개선
PEP 659 adaptive interpreter 활성화
확장 모듈 생태계 지원 확대 (Cython, pybind11, nanobind, PyO3)
🔄 Python 3.15-3.16: 안정화 및 생태계 성숙도 향상
🔮 Python 3.17+ (예상): free-threaded가 기본값이 될 가능성
Subinterpreters (PEP 554)
GIL 문제를 해결하는 또 다른 접근법:
특징:
하나의 프로세스에 여러 독립적인 Python 인터프리터
각 인터프리터가 자체 GIL 보유
multiprocessing보다 낮은 오버헤드
# Python 3.12+ 에서 사용 가능
import _xxsubinterpreters as interpreters
interp_id = interpreters.create()
interpreters.run_string(interp_id, "print('Hello from subinterpreter')")
interpreters.destroy(interp_id)
Python 3.14 Free-Threaded 실전 예제
CPU-Bound 작업 벤치마크
Python 3.14의 free-threaded 빌드는 CPU-bound 멀티스레드 작업에서 극적인 성능 향상을 보여줍니다.
Fibonacci 계산 예제:
import threading
import time
def fibonacci(n):
    """재귀적 Fibonacci 계산 (CPU-bound)"""
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
def run_benchmark(n, num_threads):
    """멀티스레드 Fibonacci 벤치마크"""
    threads = []
    start = time.time()
    for _ in range(num_threads):
        t = threading.Thread(target=lambda: fibonacci(n))
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    elapsed = time.time() - start
    return elapsed
# 테스트 실행
print("=== Fibonacci(40) 4 Threads ===")
elapsed = run_benchmark(40, 4)
print(f"Elapsed: {elapsed:.2f}s")
# 결과:
# Python 3.12 (GIL): ~1.38초
# Python 3.14 (free-threaded): ~0.28초
# 성능 향상: 약 5배
Counter 작업 예제:
import threading
import time
def count_to_billion():
    """단순 카운팅 작업 (CPU-bound)"""
    count = 0
    for i in range(1000000000):
        count += 1
    return count
def run_counter_test(num_threads):
    """멀티스레드 카운터 테스트"""
    threads = []
    start = time.time()
    for _ in range(num_threads):
        t = threading.Thread(target=count_to_billion)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    elapsed = time.time() - start
    return elapsed
# 테스트 실행
print("=== Counter Test (2 Threads) ===")
elapsed = run_counter_test(2)
print(f"Elapsed: {elapsed:.2f}s")
# 결과:
# Python 3.12 (GIL): ~37.35초
# Python 3.14 (free-threaded): ~27.21초
# 성능 향상: 약 1.4배
성능 비교 표
작업 유형
      Python 3.12 (GIL)
      Python 3.14 (Free-threaded)
      개선율
      적합성
    
Fibonacci (4 threads)
      1377ms
      279ms
      5.0x
      ✅ 매우 적합
    
Counter (2 threads)
      37.35s
      27.21s
      1.4x
      ✅ 적합
    
DataFrame 연산
      기준
      50-90% 빠름
      2-10x
      ✅ 매우 적합
    
단일 스레드 작업
      기준
      5-10% 느림
      0.9x
      ⚠️ 부적합
    
I/O-bound 작업
      기준
      거의 동일
      ~1.0x
      ⚠️ 이득 없음
    
사용 권장사항
Free-threaded Python을 사용하면 좋은 경우:
✅ CPU-bound 멀티스레드 애플리케이션
✅ 과학 계산, 데이터 분석, 머신러닝 추론
✅ 이미지/비디오 처리 (병렬 처리)
✅ 수학적 시뮬레이션
✅ 4개 이상의 코어를 활용하는 작업
일반 Python을 사용하는 것이 나은 경우:
⚠️ 단일 스레드 애플리케이션
⚠️ I/O-bound 작업 (네트워크, 파일 I/O)
⚠️ 이미 asyncio를 잘 활용하는 경우
⚠️ 확장 모듈 호환성이 중요한 경우 (아직 일부 라이브러리 미지원)
주의사항
확장 모듈 호환성:
# free-threaded 빌드에서 확장 모듈 호환성 확인
import sys
print(f"GIL enabled: {sys._is_gil_enabled()}")
# 일부 C 확장 모듈은 아직 free-threaded를 완전히 지원하지 않을 수 있음
# Cython, pybind11, nanobind, PyO3 등의 도구는 지원 작업 진행 중
메모리 사용량:
Free-threaded 빌드는 약 10% 더 많은 메모리 사용
메모리가 제한된 환경에서는 주의 필요
Key Points
GIL은 CPython의 메모리 관리를 단순화하지만, 멀티스레딩 성능을 제한함
I/O-bound 작업: Threading 또는 Async 사용
CPU-bound 작업: Multiprocessing 또는 Python 3.14 Free-threaded 사용
Python 3.14 (2025.10): Free-threaded 빌드가 공식 지원으로 승격 (PEP 779)
    
단일 스레드 페널티 5-10%로 개선 (vs 3.13의 10-15%)
CPU-bound 멀티스레드 작업에서 3-5배 성능 향상
Production-ready 상태로 바이너리 휠 및 CI 이미지 지원
PyPy: JIT 컴파일로 성능 향상, 여전히 GIL 존재
Subinterpreters: multiprocessing과 threading의 중간 지점
설치: uvx python@3.14t로 간편하게 free-threaded Python 사용 가능
Conclusion
Python의 GIL은 오랫동안 논쟁의 대상이었지만, 동시에 CPython의 단순성과 안정성을 보장해왔습니다. 2025년 10월 7일, Python 3.14의 출시와 함께 free-threaded 빌드가 공식 지원되면서, GIL이 없는 Python의 미래가 현실이 되었습니다.
Python 3.14의 의미:
PEP 779 승인으로 free-threaded가 “실험적”에서 “공식 지원”으로 승격
단일 스레드 성능 페널티가 5-10%로 크게 개선
CPU-bound 멀티스레드 작업에서 실질적인 성능 향상 (3-5배)
uvx python@3.14t로 누구나 쉽게 free-threaded Python을 사용 가능
개발자를 위한 가이드:
작업 특성 파악: I/O-bound vs CPU-bound 구분
적절한 도구 선택:
    
I/O-bound: Threading 또는 Async
CPU-bound (단일 코어): 일반 Python
CPU-bound (멀티 코어): Python 3.14 Free-threaded 또는 Multiprocessing
점진적 마이그레이션: 기존 코드는 일반 Python으로, 새 CPU-bound 프로젝트는 free-threaded로
생태계 동향 주시: Cython, pybind11 등 확장 모듈 도구의 지원 확대 추이 관찰
Python 3.14는 GIL의 종말이 아니라, 개발자에게 선택권을 제공하는 새로운 시작입니다. 필요에 따라 GIL의 단순성과 free-threaded의 성능을 선택할 수 있게 되었습니다.
Next Steps
[Python Concurrency 패턴 학습]
[Asyncio 심화 학습]
[CPython 인터프리터 내부 구조]
[Python 3.14 Free-Threaded 실전 활용 및 벤치마크]
[PyPy vs CPython vs Free-threaded Python 성능 비교]
[확장 모듈의 Free-threaded 호환성 가이드]
참고 자료
공식 문서
PEP 703 – Making the Global Interpreter Lock Optional in CPython
PEP 779 – Criteria for supported status for free-threaded Python
PEP 659 – Specializing Adaptive Interpreter
Python 3.14 Release Notes - What’s New
[Python 3.14.0 Release
          Python.org](https://www.python.org/downloads/release/python-3140/)
        
Python support for free threading — Python 3.14 Documentation
기술 분석 및 벤치마크
Python 3.14 Is Here. How Fast Is It? - Miguel Grinberg
Breaking Free: Python 3.14 Shatters the GIL Ceiling - Python Cheatsheet
[Python 3.14 and the End of the GIL
          Towards Data Science](https://towardsdatascience.com/python-3-14-and-the-end-of-the-gil/)
        
State of Python 3.13 Performance: Free-Threading - CodSpeed
Unlocking Performance in Python’s Free-Threaded Future - Quansight Labs
도구 및 생태계
Python 3.14 - Astral (uv installation guide)
Python Free-Threading Guide
PyPy Official Website
뉴스 및 커뮤니티
Python 3.14 released with cautious free-threaded support - The Register
Free-Threaded Python Unleashed - Real Python
PEP 779 Discussion - Python.org Forums
멀티스레딩 및 동시성 기초
Python threading module documentation
Python multiprocessing module documentation
Python asyncio documentation
Understanding the Python GIL - David Beazley

Python GIL

댓글