[에러 해결] [Python ThreadPoolExecutor] 데몬 스레드 활용으로 프로그램 종료 지연 방지

안녕하세요, 개발자 여러분! 오늘은 파이썬에서 시간이 오래 걸리는 객체를 비동기적으로 초기화할 때, 프로그램이 의도치 않게 종료되지 않고 계속 실행되는 문제에 대한 깊이 있는 분석과 해결책을 다루고자 합니다. 특히 concurrent.futures.ThreadPoolExecutor를 사용하면서 겪을 수 있는 ‘데몬 스레드’와 관련된 혼란을 해소하고, 구글 SEO와 사용자 경험(UX)에 최적화된 명확한 해결 방안을 제시해 드리겠습니다.

이 문서는 스택오버플로우에서 제기된 ‘Future initialization with daemon threads’ 문제에서 영감을 받았습니다. 비슷한 상황에 직면했거나 파이썬의 비동기 처리 및 스레드 관리에 관심 있는 모든 개발자에게 유용한 정보가 될 것입니다.

1. 에러 발생 상황

파이썬 애플리케이션에서 특정 객체를 초기화하는 데 매우 오랜 시간이 걸리는 경우가 있습니다. 이러한 무거운 작업을 애플리케이션 시작과 동시에 백그라운드에서 비동기적으로 시작하고 싶을 때, 우리는 concurrent.futures.ThreadPoolExecutor를 흔히 활용합니다. 하지만 여기서 예상치 못한 문제가 발생할 수 있습니다.

문제 시나리오

다음과 같은 코드를 상상해 보세요. 애플리케이션은 HeavyObject라는 객체를 백그라운드에서 초기화하기 시작합니다. 하지만 need_object 조건에 따라 이 객체가 실제로 필요하지 않을 수도 있습니다. 객체가 필요 없을 경우, 프로그램은 초기화가 완료되기 전에 종료되기를 기대합니다.

from concurrent.futures import ThreadPoolExecutor
import time

class HeavyObject:
    def __init__(self):
        print("HeavyObject: 초기화 시작 (5초 소요)...")
        time.sleep(5)
        print("HeavyObject: 초기화 완료!")

# ThreadPoolExecutor를 사용하여 객체 초기화를 백그라운드에서 시작
executor = ThreadPoolExecutor(max_workers=1)
heavy_future = executor.submit(HeavyObject)

need_object = False # 이 값을 True/False로 변경하여 테스트

if need_object:
    print("메인: 객체가 필요합니다. 결과 대기...")
    obj = heavy_future.result() # 초기화가 완료될 때까지 대기
    obj.do_something() # 객체 사용
    print("메인: 객체 사용 완료.")
else:
    print("메인: 객체가 필요 없습니다. 프로그램 종료를 시도합니다...")
    # heavy_future.result()가 호출되지 않음

# with 문을 사용하지 않았으므로, 명시적 종료가 필요.
# 하지만 여기서는 종료 시도를 하지 않고, 데몬 스레드 여부 테스트에 집중.
# executor.shutdown() # 일반적으로는 필요

print("메인: 메인 스레드 종료 신호.")
# 이 시점에서 프로그램이 바로 종료될까요? 아니면 5초를 기다려야 할까요?

위 코드에서 need_object가 False인 경우, 프로그램은 heavy_future.result()를 호출하지 않고 종료되기를 기대합니다. 하지만 실제로는 HeavyObject의 초기화가 완료될 때까지 약 5초간 프로그램이 멈춰 있는 것을 발견하게 될 것입니다. 이것이 바로 우리가 해결하려는 문제입니다.

2. 명확한 발생 원인

이러한 현상의 핵심 원인은 파이썬의 스레드 종류와 ThreadPoolExecutor의 기본 동작 방식에 있습니다.

2.1. 데몬 스레드 vs. 비(Non)-데몬 스레드

• 비(Non)-데몬 스레드 (Non-Daemon Thread): 기본적으로 파이썬에서 생성되는 모든 스레드는 비(non)-데몬 스레드입니다. 비(non)-데몬 스레드가 실행 중인 동안에는 파이썬 인터프리터가 종료되지 않습니다. 즉, 모든 비(non)-데몬 스레드가 작업을 마쳐야만 프로그램이 완전히 종료됩니다.
• 데몬 스레드 (Daemon Thread): 데몬 스레드는 메인 스레드가 종료되면 백그라운드에서 실행 중이더라도 자동으로 강제 종료되는 스레드입니다. 이는 메인 프로그램의 생명주기에 종속되어 보조적인 작업을 수행할 때 유용합니다. 메인 스레드가 종료되면, 데몬 스레드가 하던 작업이 끝나지 않았더라도 함께 종료됩니다.

2.2. ThreadPoolExecutor의 기본 동작

concurrent.futures.ThreadPoolExecutor는 기본적으로 비(non)-데몬 스레드를 사용하여 워커 스레드를 생성합니다. 이는 일반적인 스레드 풀의 사용 목적에 부합합니다. 즉, 백그라운드에서 시작된 모든 작업이 완료될 때까지 프로그램이 종료되지 않도록 보장하여, 데이터 손실이나 미완료 작업으로 인한 문제를 방지하려는 의도입니다.

2.3. 문제의 충돌

우리가 겪는 문제는 바로 이 지점에서 발생합니다. 우리는 객체가 필요 없을 경우 백그라운드 초기화 스레드가 여전히 실행 중이더라도 메인 프로그램이 즉시 종료되기를 원합니다. 하지만 ThreadPoolExecutor의 비(non)-데몬 스레드는 메인 스레드의 종료를 막고, 초기화 작업이 완료될 때까지 대기하게 만듭니다. 결과적으로 프로그램은 ‘멈춘’ 것처럼 보이게 되는 것입니다.

3. 해결 방법 및 코드 예시

ThreadPoolExecutor는 스레드를 데몬으로 직접 설정하는 옵션을 제공하지 않습니다. 따라서 우리의 요구사항을 충족시키기 위해서는 몇 가지 접근 방식을 고려해야 합니다.

3.1. 가장 직접적이고 실용적인 해결책: AsyncInitializer 구현

질문자님이 직접 구현하신 AsyncInitializer 클래스는 concurrent.futures.Future와 유사한 비동기 인터페이스를 제공하면서도, 내부적으로 daemon=True로 설정된 스레드를 사용하여 프로그램을 유연하게 종료시킬 수 있는 훌륭한 해결책입니다. 이는 ThreadPoolExecutor의 한계를 극복하기 위한 실용적인 접근 방식이며, “바퀴를 재발명”하는 것이 아니라 특정 요구사항을 충족시키기 위한 필요한 구현으로 볼 수 있습니다.

아래는 데몬 스레드를 활용한 AsyncInitializer 클래스의 개선된 코드와 사용 예시입니다.

from threading import Thread
from typing import Callable, Generic, TypeVar, Union
import time

T = TypeVar("T")

class AsyncInitializer(Generic[T]):
    def __init__(self, initializer: Callable[[], T]):
        self.value: Union[T, None] = None
        self.exception: Union[Exception, None] = None
        self._initializer = initializer

        # 핵심: 스레드를 데몬으로 설정하여 메인 프로그램 종료 시 자동 종료되도록 함
        self._thread = Thread(target=self._initialize, daemon=True)
        self._thread.start()
        print("AsyncInitializer: 초기화 스레드 시작 (데몬).")

    def _initialize(self) -> None:
        """백그라운드에서 객체를 초기화하는 메서드"""
        try:
            self.value = self._initializer()
        except Exception as e:
            self.exception = e
            print(f"AsyncInitializer: 초기화 중 에러 발생: {e}")
        finally:
            print("AsyncInitializer: 초기화 스레드 작업 완료.")

    def get(self) -> T:
        """초기화된 객체를 반환. 초기화가 완료될 때까지 대기."""
        print("AsyncInitializer: get() 호출. 초기화 완료까지 대기 중...")
        self._thread.join() # 초기화 스레드가 완료될 때까지 대기

        if self.exception is not None:
            raise self.exception # 초기화 중 발생한 예외 재발생
        
        # 초기화 함수가 None을 반환하거나 실패했을 때 대비
        if self.value is None:
            raise RuntimeError("Initialization failed or returned None unexpectedly.")

        return self.value # type: ignore [return-value] # value는 T로 확신

# ---- 사용 예시 ----

class HeavyObject:
    def __init__(self):
        print("HeavyObject: 초기화 시작 (5초 소요)...")
        time.sleep(5)
        print("HeavyObject: 초기화 완료!")
        self.name = "HeavyObject Instance"

    def do_something(self):
        print(f"HeavyObject: {self.name}으로 작업 수행.")

def create_heavy_object():
    """HeavyObject를 생성하는 함수"""
    return HeavyObject()

print("--- Case 1: 객체가 필요할 경우 ---")
# 객체가 필요하므로 초기화 완료를 기다림
heavy_obj_future_needed = AsyncInitializer(create_heavy_object)
print("메인: 다른 작업 수행 중 (2초)...")
time.sleep(2)
obj_needed = heavy_obj_future_needed.get() # 여기서 남은 초기화 시간(약 3초) 대기
print(f"메인: 객체 사용 - {obj_needed.name}")
obj_needed.do_something()
print("메인: Case 1 완료.")

print("\n" + "="*50 + "\n")

print("--- Case 2: 객체가 필요 없을 경우 (데몬 스레드 동작 확인) ---")
# 객체가 필요 없으므로 메인 스레드가 즉시 종료되도록 함
heavy_obj_future_not_needed = AsyncInitializer(create_heavy_object)
print("메인: 객체 필요 없으므로, 메인 스레드는 바로 종료됩니다.")
print("메인: Case 2 완료. 데몬 스레드는 메인 스레드와 함께 종료됩니다.")
# 이 시점에서 프로그램은 HeavyObject 초기화가 완료될 때까지 기다리지 않고 바로 종료됩니다.
# (출력에서 HeavyObject: 초기화 완료! 메시지가 나오지 않을 수 있음)

이 AsyncInitializer는 Future 객체와 유사하게 비동기 작업의 결과를 캡슐화하고, 필요할 때 get() 메서드를 통해 결과를 얻을 수 있습니다. 핵심은 daemon=True 설정으로, 메인 프로그램의 생명주기에 따라 백그라운드 초기화 스레드의 생명주기가 결정된다는 점입니다.

3.2. 대안: concurrent.futures.ProcessPoolExecutor 고려

만약 작업이 CPU 바운드(CPU 집약적)이며, 스레드의 공유 메모리 문제가 없고 Python의 GIL(Global Interpreter Lock)의 제약을 피하고 싶다면 ProcessPoolExecutor를 대안으로 고려해볼 수 있습니다. ProcessPoolExecutor가 생성하는 프로세스들은 기본적으로 데몬 프로세스처럼 동작합니다. 즉, 메인 프로세스가 종료되면 백그라운드에서 실행 중이던 모든 워커 프로세스도 강제로 종료됩니다.

import concurrent.futures
import time

class HeavyObject:
    def __init__(self):
        print("HeavyObject (프로세스): 초기화 시작 (5초 소요)...")
        time.sleep(5)
        print("HeavyObject (프로세스): 초기화 완료!")
        self.name = "HeavyObject Instance (Process)"

    def do_something(self):
        print(f"HeavyObject (프로세스): {self.name}으로 작업 수행.")

def create_heavy_object_process_safe():
    """ProcessPoolExecutor를 위해 HeavyObject를 생성하는 함수 (피클링 가능해야 함)"""
    return HeavyObject()

if __name__ == "__main__": # ProcessPoolExecutor는 __main__ 가드가 필요합니다.
    print("--- Case 3: ProcessPoolExecutor 활용 (객체 불필요 시) ---")
    # with 문을 사용하여 Executor의 생명주기를 관리
    with concurrent.futures.ProcessPoolExecutor(max_workers=1) as executor:
        heavy_future_process = executor.submit(create_heavy_object_process_safe)
        print("메인 (프로세스): 객체 필요 없습니다. 메인 프로세스 종료를 시도합니다...")
    # with 블록 종료 시, heavy_future_process.result()가 호출되지 않았더라도
    # 데몬 프로세스는 메인 프로세스 종료와 함께 정리됩니다.
    print("메인 (프로세스): 프로그램 종료. (HeavyObject 초기화 대기 없이 종료)")
    # 이 시점에서 HeavyObject: 초기화 완료! 메시지가 나오지 않을 수 있습니다.

이 방법은 스레드 대신 프로세스를 사용하므로, 스레드와 관련된 제약(GIL 등)을 피할 수 있지만, 프로세스 간 통신 오버헤드나 자원 사용량 증가를 고려해야 합니다.

4. 향후 예방을 위한 팁

이와 같은 문제를 재발 방지하고, 파이썬의 동시성 프로그래밍을 더욱 효율적으로 활용하기 위한 몇 가지 팁입니다.

• 스레드/프로세스 유형의 이해

  파이썬에서 스레드(threading.Thread)를 사용할 때는 데몬 스레드와 비(non)-데몬 스레드의 차이를 명확히 이해하는 것이 중요합니다. 프로그램의 메인 로직과 독립적으로 백그라운드에서 실행되다가 메인 프로그램 종료 시 함께 정리되어야 하는 작업(예: 로깅, 모니터링, 선택적 초기화)에는 데몬 스레드를 사용하는 것이 적절합니다. 반면, 반드시 완료되어야 하는 중요한 백그라운드 작업(예: 데이터 저장, 중요한 계산)에는 비(non)-데몬 스레드를 사용하거나, Executor.shutdown()과 같은 명시적인 종료 메커니즘을 고려해야 합니다.

• Executor 선택의 신중함

  concurrent.futures 모듈을 사용할 때는 ThreadPoolExecutor와 ProcessPoolExecutor 중 어떤 것이 애플리케이션의 요구사항에 더 적합한지 신중하게 고려해야 합니다.

  • ThreadPoolExecutor: I/O 바운드(네트워크 요청, 파일 읽기/쓰기 등) 작업에 유리합니다. 스레드는 메모리를 공유하므로 데이터 전달이 용이하지만, GIL 때문에 CPU 바운드 작업에서는 성능 이득이 제한적입니다. 기본적으로 비(non)-데몬 스레드를 사용하므로, 명시적인 종료 관리가 필요할 수 있습니다.
  • ProcessPoolExecutor: CPU 바운드(복잡한 계산, 데이터 처리 등) 작업에 유리하며 GIL의 제약을 받지 않습니다. 각 프로세스는 독립적인 메모리 공간을 가지므로 데이터 직렬화/역직렬화(pickling) 오버헤드가 발생할 수 있습니다. 데몬 프로세스처럼 동작하여 메인 프로세스 종료 시 자동으로 정리되는 특성이 있습니다.

• 자원 해제 습관화

  ThreadPoolExecutor나 ProcessPoolExecutor를 사용할 때는 반드시 with 문을 사용하거나, 사용 후에는 executor.shutdown()을 명시적으로 호출하여 스레드/프로세스 풀의 자원을 적절히 해제하는 습관을 들이는 것이 중요합니다. 이는 리소스 누수를 방지하고 프로그램이 깔끔하게 종료되도록 돕습니다.

이 문서를 통해 파이썬에서 비동기 객체 초기화 시 데몬 스레드의 중요성과 ThreadPoolExecutor의 한계를 명확히 이해하고, 실용적인 해결책을 찾는 데 도움이 되셨기를 바랍니다. 여러분의 코드가 더욱 견고하고 효율적으로 작동하기를 기원합니다!