Python에서 동시성 잠금 해제: ThreadPoolExecutor vs ProcessPoolExecutor

Python은 다재다능하고 널리 사용되는 프로그래밍 언어이지만, 전역 인터프리터 잠금(GIL)으로 인해 진정한 병렬성 측면에서 특정 한계가 있습니다. concurrent.futures 모듈은 호출 가능한 객체를 비동기적으로 실행하기 위한 고수준 인터페이스를 제공하며, 이러한 한계를 일부 극복하고 특정 유형의 작업 성능을 향상시키는 방법을 제공합니다. 이 모듈은 두 가지 주요 클래스인 ThreadPoolExecutor와 ProcessPoolExecutor를 제공합니다. 이 종합 가이드에서는 두 가지를 모두 탐색하고, 차이점, 강점 및 약점을 강조하며, 필요에 맞는 적절한 실행기를 선택하는 데 도움이 되는 실용적인 예제를 제공합니다.

동시성과 병렬성 이해하기

각 실행기의 특정 내용을 살펴보기 전에 동시성과 병렬성의 개념을 이해하는 것이 중요합니다. 이 용어들은 종종 혼용되지만 뚜렷한 의미를 가집니다.

• 동시성: 여러 작업을 동시에 관리하는 것과 관련이 있습니다. 실제로 단일 프로세서 코어에서 인터리빙되더라도 여러 작업을 동시에 처리하도록 코드를 구성하는 것입니다. 단일 스토브에서 여러 냄비를 관리하는 요리사를 생각해보세요. 모든 냄비가 *정확히* 동시에 끓고 있는 것은 아니지만, 요리사는 모든 냄비를 관리하고 있습니다.
• 병렬성: 일반적으로 여러 프로세서 코어를 활용하여 실제로 여러 작업을 *동시에* 실행하는 것을 포함합니다. 이는 여러 명의 요리사가 동시에 식사의 다른 부분에서 작업하는 것과 같습니다.

Python의 GIL은 스레드를 사용할 때 CPU 바운드 작업에 대한 진정한 병렬성을 거의 방지합니다. 이는 GIL이 주어진 시간에 단 하나의 스레드만 Python 인터프리터 제어권을 가질 수 있도록 허용하기 때문입니다. 그러나 프로그램이 네트워크 요청이나 디스크 읽기와 같은 외부 작업을 기다리는 데 대부분의 시간을 소비하는 I/O 바운드 작업의 경우, 한 스레드가 기다리는 동안 다른 스레드가 실행될 수 있도록 하여 스레드가 여전히 상당한 성능 향상을 제공할 수 있습니다.

`concurrent.futures` 모듈 소개

concurrent.futures 모듈은 비동기적으로 작업을 실행하는 프로세스를 단순화합니다. 스레드 및 프로세스와 함께 작업하기 위한 고수준 인터페이스를 제공하며, 직접 관리하는 데 필요한 복잡성의 대부분을 추상화합니다. 핵심 개념은 제출된 작업의 실행을 관리하는 "실행기"입니다. 두 가지 주요 실행기는 다음과 같습니다.

• ThreadPoolExecutor: 작업을 실행하기 위해 스레드 풀을 활용합니다. I/O 바운드 작업에 적합합니다.
• ProcessPoolExecutor: 작업을 실행하기 위해 프로세스 풀을 활용합니다. CPU 바운드 작업에 적합합니다.

ThreadPoolExecutor: I/O 바운드 작업을 위한 스레드 활용

ThreadPoolExecutor는 작업 실행을 위해 워커 스레드 풀을 생성합니다. GIL 때문에 스레드는 진정한 병렬성의 이점을 얻는 계산 집약적인 작업에 이상적이지 않습니다. 그러나 I/O 바운드 시나리오에서는 뛰어납니다. 사용 방법을 살펴보겠습니다.

기본 사용법

다음은 여러 웹 페이지를 동시적으로 다운로드하기 위해 ThreadPoolExecutor를 사용하는 간단한 예제입니다.

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # 잘못된 응답 (4xx 또는 5xx)에 대해 HTTPError 발생
        print(f"Downloaded {url}: {len(response.content)} bytes")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # 각 URL을 실행기로 제출
    futures = [executor.submit(download_page, url) for url in urls]

    # 모든 작업이 완료될 때까지 대기
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Total bytes downloaded: {total_bytes}")
print(f"Time taken: {time.time() - start_time:.2f} seconds")

설명:

1. 필요한 모듈(concurrent.futures, requests, time)을 가져옵니다.
2. 다운로드할 URL 목록을 정의합니다.
3. download_page 함수는 주어진 URL의 내용을 검색합니다. `try...except`와 `response.raise_for_status()`를 사용하여 오류 처리를 포함하여 잠재적인 네트워크 문제를 포착합니다.
4. 최대 4개의 워커 스레드를 사용하여 ThreadPoolExecutor를 생성합니다. max_workers 인수는 동시에 사용할 수 있는 최대 스레드 수를 제어합니다. 너무 높게 설정하면 특히 네트워크 대역폭이 병목 현상인 I/O 바운드 작업에서 항상 성능이 향상되지 않을 수 있습니다.
5. 리스트 컴프리헨션을 사용하여 executor.submit(download_page, url)을 통해 각 URL을 실행기로 제출합니다. 이는 각 작업에 대해 Future 객체를 반환합니다.
6. concurrent.futures.as_completed(futures) 함수는 완료되는 대로 미래를 생성하는 반복자를 반환합니다. 이를 통해 결과를 처리하기 전에 모든 작업이 완료될 때까지 기다리는 것을 방지할 수 있습니다.
7. 완료된 미래를 반복하고 future.result()를 사용하여 각 작업의 결과를 검색하고 다운로드된 총 바이트를 합산합니다. `download_page` 내의 오류 처리는 개별 실패가 전체 프로세스를 중단시키지 않도록 합니다.
8. 마지막으로 다운로드된 총 바이트와 소요된 시간을 출력합니다.

ThreadPoolExecutor의 이점

• 간소화된 동시성: 스레드 관리를 위한 깔끔하고 사용하기 쉬운 인터페이스를 제공합니다.
• I/O 바운드 성능: 네트워크 요청, 파일 읽기 또는 데이터베이스 쿼리와 같이 상당한 시간을 I/O 작업 대기에 소비하는 작업에 탁월합니다.
• 낮은 오버헤드: 스레드는 일반적으로 프로세스에 비해 오버헤드가 낮아 잦은 컨텍스트 전환이 포함된 작업에 더 효율적입니다.

ThreadPoolExecutor의 한계

• GIL 제한: GIL은 CPU 바운드 작업에 대한 진정한 병렬성을 제한합니다. 한 번에 하나의 스레드만 Python 바이트코드를 실행할 수 있어 여러 코어의 이점을 무효화합니다.
• 디버깅 복잡성: 멀티스레드 애플리케이션 디버깅은 레이스 컨디션 및 기타 동시성 관련 문제로 인해 어려울 수 있습니다.

ProcessPoolExecutor: CPU 바운드 작업을 위한 멀티프로세싱 활용

ProcessPoolExecutor는 워커 프로세스 풀을 생성하여 GIL 제한을 극복합니다. 각 프로세스는 자체 Python 인터프리터와 메모리 공간을 가지므로 멀티코어 시스템에서 진정한 병렬성을 허용합니다. 이는 무거운 계산이 포함된 CPU 바운드 작업에 이상적입니다.

기본 사용법

많은 수의 숫자에 대한 제곱 합 계산과 같은 계산 집약적인 작업을 고려해 보세요. ProcessPoolExecutor를 사용하여 이 작업을 병렬화하는 방법은 다음과 같습니다.

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Process ID: {pid}, Calculating sum of squares from {start} to {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": # 일부 환경에서 재귀적 스패닝을 피하기 위해 중요
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Total sum of squares: {total_sum}")
    print(f"Time taken: {time.time() - start_time:.2f} seconds")

설명:

1. 주어진 숫자 범위에 대한 제곱 합을 계산하는 sum_of_squares 함수를 정의합니다. 각 범위가 어떤 프로세스에서 실행되는지 확인하기 위해 os.getpid()를 포함합니다.
2. 범위 크기와 사용할 프로세스 수를 정의합니다. ranges 목록은 총 계산 범위를 각 프로세스에 대해 하나씩 더 작은 청크로 나누기 위해 생성됩니다.
3. 지정된 수의 워커 프로세스로 ProcessPoolExecutor를 생성합니다.
4. executor.submit(sum_of_squares, start, end)를 사용하여 각 범위를 실행기로 제출합니다.
5. future.result()를 사용하여 각 미래에서 결과를 수집합니다.
6. 모든 프로세스의 결과를 합산하여 최종 총계를 얻습니다.

중요 참고 사항: ProcessPoolExecutor를 사용할 때, 특히 Windows에서는 실행기를 생성하는 코드를 if __name__ == "__main__": 블록으로 묶어야 합니다. 이는 프로세스가 재귀적으로 스패닝되는 것을 방지하여 오류와 예상치 못한 동작을 유발할 수 있습니다. 이는 모듈이 각 하위 프로세스에서 다시 가져오기 때문입니다.

ProcessPoolExecutor의 이점

• 진정한 병렬성: GIL 제한을 극복하여 CPU 바운드 작업에 대해 멀티코어 시스템에서 진정한 병렬성을 허용합니다.
• CPU 바운드 작업에 대한 성능 향상: 계산 집약적인 작업에 대해 상당한 성능 향상을 달성할 수 있습니다.
• 견고성: 한 프로세스가 충돌하더라도 프로세스는 서로 격리되어 있으므로 전체 프로그램이 다운되지 않을 수 있습니다.

ProcessPoolExecutor의 한계

• 높은 오버헤드: 프로세스 생성 및 관리는 스레드에 비해 오버헤드가 높습니다.
• 프로세스 간 통신: 프로세스 간 데이터 공유는 더 복잡할 수 있으며 오버헤드를 추가할 수 있는 프로세스 간 통신(IPC) 메커니즘이 필요합니다.
• 메모리 사용량: 각 프로세스는 자체 메모리 공간을 가지므로 애플리케이션의 전체 메모리 사용량이 증가할 수 있습니다. 프로세스 간에 많은 양의 데이터를 전달하는 것은 병목 현상이 될 수 있습니다.

올바른 실행기 선택: ThreadPoolExecutor vs ProcessPoolExecutor

ThreadPoolExecutor와 ProcessPoolExecutor 중에서 선택하는 열쇠는 작업의 성격을 이해하는 데 있습니다.

• I/O 바운드 작업: 작업이 I/O 작업(예: 네트워크 요청, 파일 읽기, 데이터베이스 쿼리)을 기다리는 데 대부분의 시간을 소비하는 경우 ThreadPoolExecutor가 일반적으로 더 나은 선택입니다. 이러한 시나리오에서는 GIL이 병목 현상이 덜하며 스레드의 낮은 오버헤드가 더 효율적입니다.
• CPU 바운드 작업: 작업이 계산 집약적이고 여러 코어를 활용하는 경우 ProcessPoolExecutor가 정답입니다. GIL 제한을 우회하고 진정한 병렬성을 허용하여 상당한 성능 향상을 가져옵니다.

다음 표는 주요 차이점을 요약한 것입니다.

기능	ThreadPoolExecutor	ProcessPoolExecutor
동시성 모델	멀티스레딩	멀티프로세싱
GIL 영향	GIL에 의해 제한됨	GIL 우회
적합한 작업	I/O 바운드 작업	CPU 바운드 작업
오버헤드	낮음	높음
메모리 사용량	낮음	높음
프로세스 간 통신	필요 없음 (스레드는 메모리 공유)	데이터 공유에 필요
견고성	덜 견고함 (충돌 시 전체 프로세스에 영향)	더 견고함 (프로세스 격리)

고급 기법 및 고려 사항

인수와 함께 작업 제출

두 실행기 모두 실행 중인 함수에 인수를 전달할 수 있습니다. 이는 submit() 메서드를 통해 수행됩니다.

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

예외 처리

실행된 함수 내에서 발생하는 예외는 메인 스레드 또는 프로세스로 자동으로 전파되지 않습니다. Future 결과를 검색할 때 명시적으로 처리해야 합니다.

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"An exception occurred: {e}")

단순 작업에 `map` 사용

입력 시퀀스에 동일한 함수를 적용하려는 간단한 작업의 경우, map() 메서드는 작업을 제출하는 간결한 방법을 제공합니다.

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

작업자 수 제어

ThreadPoolExecutor 및 ProcessPoolExecutor 모두의 max_workers 인수는 동시에 사용할 수 있는 최대 스레드 또는 프로세스 수를 제어합니다. max_workers에 대한 올바른 값을 선택하는 것은 성능에 중요합니다. 좋은 시작점은 시스템에서 사용 가능한 CPU 코어 수입니다. 그러나 I/O 바운드 작업의 경우 스레드가 I/O를 기다리는 동안 다른 작업으로 전환될 수 있으므로 코어보다 더 많은 스레드를 사용하는 것이 유리할 수 있습니다. 특정 사용 사례에 대한 최적 값을 결정하려면 실험 및 프로파일링이 종종 필요합니다.

진행 상황 모니터링

concurrent.futures 모듈은 작업 진행 상황을 직접 모니터링하기 위한 내장 메커니즘을 제공하지 않습니다. 그러나 콜백이나 공유 변수를 사용하여 자체 진행 상황 추적을 구현할 수 있습니다. `tqdm`과 같은 라이브러리는 진행률 표시줄을 표시하도록 통합될 수 있습니다.

실제 예시

ThreadPoolExecutor와 ProcessPoolExecutor를 효과적으로 적용할 수 있는 몇 가지 실제 시나리오를 고려해 보겠습니다.

• 웹 스크래핑: ThreadPoolExecutor를 사용하여 여러 웹 페이지를 동시적으로 다운로드하고 구문 분석합니다. 각 스레드는 다른 웹 페이지를 처리하여 전체 스크래핑 속도를 향상시킬 수 있습니다. 웹사이트 이용 약관을 주의하고 서버에 과부하를 주지 않도록 주의하세요.
• 이미지 처리: ProcessPoolExecutor를 사용하여 대량의 이미지에 이미지 필터 또는 변환을 적용합니다. 각 프로세스는 다른 이미지를 처리하여 여러 코어를 활용하여 더 빠른 처리를 할 수 있습니다. 효율적인 이미지 처리를 위해 OpenCV와 같은 라이브러리를 고려하세요.
• 데이터 분석: ProcessPoolExecutor를 사용하여 대규모 데이터 세트에 대한 복잡한 계산을 수행합니다. 각 프로세스는 데이터의 하위 집합을 분석하여 전체 분석 시간을 단축할 수 있습니다. Pandas 및 NumPy는 Python에서 데이터 분석에 널리 사용되는 라이브러리입니다.
• 기계 학습: ProcessPoolExecutor를 사용하여 기계 학습 모델을 훈련합니다. 일부 기계 학습 알고리즘은 효과적으로 병렬화되어 더 빠른 훈련 시간을 허용할 수 있습니다. scikit-learn 및 TensorFlow와 같은 라이브러리는 병렬화를 지원합니다.
• 비디오 인코딩: ProcessPoolExecutor를 사용하여 비디오 파일을 다른 형식으로 변환합니다. 각 프로세스는 다른 비디오 세그먼트를 인코딩하여 전체 인코딩 프로세스를 더 빠르게 만들 수 있습니다.

글로벌 고려 사항

전 세계적인 청중을 위한 동시 애플리케이션을 개발할 때는 다음 사항을 고려하는 것이 중요합니다.

• 시간대: 시간 관련 작업을 다룰 때 시간대를 염두에 두십시오. `pytz`와 같은 라이브러리를 사용하여 시간대 변환을 처리합니다.
• 로캘: 애플리케이션이 다른 로캘을 올바르게 처리하는지 확인합니다. `locale`과 같은 라이브러리를 사용하여 사용자의 로캘에 따라 숫자, 날짜 및 통화를 형식화합니다.
• 문자 인코딩: 다양한 언어를 지원하기 위해 기본 문자 인코딩으로 유니코드(UTF-8)를 사용합니다.
• 국제화(i18n) 및 현지화(l10n): 애플리케이션을 쉽게 국제화 및 현지화할 수 있도록 설계합니다. gettext 또는 기타 번역 라이브러리를 사용하여 다른 언어에 대한 번역을 제공합니다.
• 네트워크 지연 시간: 원격 서비스와 통신할 때 네트워크 지연 시간을 고려하십시오. 애플리케이션이 네트워크 문제에 복원력이 있는지 확인하기 위해 적절한 타임아웃 및 오류 처리를 구현하십시오. 서버의 지리적 위치는 지연 시간에 상당한 영향을 미칠 수 있습니다. 다른 지역의 사용자에게 성능을 향상시키기 위해 콘텐츠 전송 네트워크(CDN) 사용을 고려하십시오.

결론

concurrent.futures 모듈은 Python 애플리케이션에 동시성과 병렬성을 도입할 수 있는 강력하고 편리한 방법을 제공합니다. ThreadPoolExecutor와 ProcessPoolExecutor 간의 차이점을 이해하고 작업의 성격을 신중하게 고려함으로써 코드의 성능과 응답성을 크게 향상시킬 수 있습니다. 특정 사용 사례에 대한 최적 설정을 찾기 위해 코드를 프로파일링하고 다양한 구성을 실험하는 것을 잊지 마십시오. 또한 GIL의 한계와 멀티스레딩 및 멀티프로세싱 프로그래밍의 잠재적인 복잡성에 유의하십시오. 신중한 계획과 구현을 통해 Python에서 동시성의 잠재력을 최대한 발휘하고 전 세계적인 청중을 위한 견고하고 확장 가능한 애플리케이션을 만들 수 있습니다.