[Python / GUI] QThread 안전하게 종료하는 방법

JaehyoJJAng2024년 08월 19일

개요

오늘은 GUI 애플리케이션을 개발할 때 자주 겪는 스레드 종료 문제 에 대해 알아보려고 한다.

보통 QThread를 활용한 백그라운드 작업을 모두 수행하고나서

애플리케이션 종료할 때, 스레드가 제대로 종료되지 않아 프로그램이 "응답 없음" 상태가 되는 경우가 발생한다.

이번 포스팅에서는 그 문제를 해결하는 방법을 기록할 것이다.

문제 상황

GUI 애플리케이션을 개발할 때, 백그라운드에서 지속적으로 작업을 수행하는 스레드를 구현하는 경우가 많다.

(웹 사이트에서 주기적으로 데이터를 가져오기, 등등 ..)

그러나 애플리케이션을 종료할 때, 실행 중인 스레드가 즉시 종료되지 않고 오랜 시간 동안 대기 상태에 머물러 "응답 없음" 상태가 되는 문제가 발생할 수 있다.

이는 주로 스레드 내에서 긴 time.sleep() 등의 호출로 인해 종료 요청을 즉시 반영하지 못하기 때문이다.

이러한 문제를 해결하기 위해서는 스레드가 종료 요청을 신속하게 감지하고 안전하게 종료될 수 있도록 설계해야 한다.

기존 코드 분석

문제("응답 없음")를 일으키는 프로그램을 간단하게 구현해보자.

from PySide6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QLabel, QLineEdit
from PySide6.QtCore import QThread, Signal
from threading import Event
import time
import requests

class ScrapingThread(QThread):
    new_post_signal = Signal(str)
    error_signal = Signal(str)
    
    def __init__(self, login_info, comment_text):
        super().__init__()
        self.pause_event = Event()
        self.pause_event.set()
        self.running = True
        self.login_info = login_info
        self.comment_text = comment_text
        self.session = requests.Session()
        self.logged_in = False
    
    def run(self):
        try:
            if not self.logged_in:
                self.perform_login()
            while self.running:
                self.pause_event.wait()  # 일시정지 상태에서는 대기
                new_post = self.check_new_post()
                if new_post:
                    self.add_comment(new_post)
                time.sleep(60)  # 1분 대기
        except Exception as e:
            self.error_signal.emit(str(e))
    
    # 핵심 로직 구현 ...

위 코드에서 run 메소드는 무한 루프를 돌며 새로운 게시글을 확인하고 댓글을 작성한 후, time.sleep(60)으로 1분 동안 대기한다.

그러나 애플리케이션을 종료할 때, 이 time.sleep(60) 동안 스레드는 종료 요청을 즉시 처리하지 못하고 최대 60초 동안 대기하게 되어 "응답 없음" 상태가 된다.

QThread의 인터럽트 매커니즘 사용하기

이 문제를 해결하기 위해 QThread의 인터럽트 매커니즘 을 활용할 수 있다.

QThread는 requestInterruption()과 isInterruptionRequested() 메소드를 제공하여 스레드에 종료 요청을 보낼 수 있다.

이를 통해 스레드가 종료 요청을 감지하고 적절히 종료할 수 있게된다.

주요 메소드 설명

requestInterruption(): 스레드에 인터럽트 요청을 보냄
isInterruptionRequested(): 스레드가 인터럽트 요청을 받았는지 확인함

코드 수정하기

이제 문제가 발생하는 기존 코드를 수정하여 QThread의 인터럽트 매커니즘을 적용해보자.

from PySide6.QtCore import QThread, Signal
from threading import Event
import time
import requests

class ScrapingThread(QThread):
    new_post_signal = Signal(str)
    error_signal = Signal(str)

    def __init__(self):
        super().__init__()
        self.pause_event = Event()
        self.pause_event.set()
    
    def run(self):
        try:
            while not self.isInterruptionRequested():
                self.pause_event.wait()  # 일시정지 상태에서는 대기
                if self.isInterruptionRequested():
                    break  # 인터럽트 요청 시 루프 종료
                
                # 60초 동안 1초 간격으로 대기하여 종료 요청을 신속히 반영
                for _ in range(60):
                    if self.isInterruptionRequested():
                        break
                    time.sleep(1)
        except Exception as e:
            self.error_signal.emit(str(e))
    
    def pause(self):
        self.pause_event.clear()
    
    def resume(self):
        self.pause_event.set()

주요 변경 사항

인터럽트 요청 확인: while not self.isInterruptionRequested(): 조건을 사용하여 인터럽트 요청이 있는지 확인한다.
짧은 간격으로 대기: time.sleep(60) 대신 1초 간격으로 60번 반복하며 인터럽트 요청을 감지할 수 있도록 변경하였다. 이를 통해 최대 60초의 지연 없이 종료 요청을 반영할 수 있게 된다.
인터럽트 요청 시 루프 종료: 루프 내에서 if self.isInterruptionRequested(): break를 추가하여 인터럽트 요청 시 즉시 루프를 종료하도록 변경하였다.

UI 앱 코드는 다음과 같다.

from PySide6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QLabel, QLineEdit
from PySide6.QtCore import QThread, Signal
from threading import Event
import time
import requests

class CommentAutomationApp(QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()
        self.scraping_thread = None  # 스레드 초기화
    
    def init_ui(self):        
        # 버튼 생성
        self.login_button = QPushButton("로그인", self)
        self.start_button = QPushButton("시작", self)
        self.pause_button = QPushButton("일시정지", self)
        self.resume_button = QPushButton("재개", self)
        
        # 초기 버튼 상태 설정
        self.start_button.setEnabled(False)
        self.pause_button.setEnabled(False)
        self.resume_button.setEnabled(False)
        
        # 버튼 클릭 이벤트 연결
        self.login_button.clicked.connect(self.login)
        self.start_button.clicked.connect(self.start_scraping)
        self.pause_button.clicked.connect(self.pause_scraping)
        self.resume_button.clicked.connect(self.resume_scraping)
    
    def start_scraping(self):
        if self.scraping_thread and not self.scraping_thread.isRunning():
            self.scraping_thread.start()
            self.status_label.setText("상태: 자동화 시작")
            self.start_button.setEnabled(False)
            self.pause_button.setEnabled(True)
            self.login_button.setEnabled(False)
    
    def pause_scraping(self):
        if self.scraping_thread and self.scraping_thread.isRunning():
            self.scraping_thread.pause()
            self.status_label.setText("상태: 자동화 일시정지")
            self.pause_button.setEnabled(False)
            self.resume_button.setEnabled(True)
    
    def resume_scraping(self):
        if self.scraping_thread and self.scraping_thread.isRunning():
            self.scraping_thread.resume()
            self.status_label.setText("상태: 자동화 재개")
            self.pause_button.setEnabled(True)
            self.resume_button.setEnabled(False)
    
    def handle_error(self, error_message):
        self.status_label.setText(f"오류: {error_message}")
        self.start_button.setEnabled(False)
        self.pause_button.setEnabled(False)
        self.resume_button.setEnabled(False)
        self.login_button.setEnabled(True)
    
    def closeEvent(self, event):
        # 프로그램 종료 시 스레드 안전하게 종료
        if self.scraping_thread and self.scraping_thread.isRunning():
            self.scraping_thread.requestInterruption()  # 인터럽트 요청
            self.scraping_thread.wait()  # 스레드가 종료될 때까지 대기
        event.accept()

closeEvent 메소드: 애플리케이션 종료 시 requestInterruption()을 호출하여 스레드에 인터럽트 요청을 보낸다. 그 후 wait()을 호출하여 스레드가 종료될 때까지 기다린다
스레드 상태 관리: 스레드의 시작, 일시정지, 재개 버튼의 상태를 적절히 관리하여 사용자가 원하는 대로 스레드를 제어할 수 있도록 하였다.

for 문이 여러 겹인 경우

for 문이 여러 겹인 상황에서는 어떻게 처리하는지 알아보자.

1. 제어 플래그 추가

_is_running: 작업 실행 여부를 제어.
_is_paused: 작업 일시 정지 여부를 제어.

from PyQt5.QtCore import QThread, pyqtSignal
import requests as rq
from bs4 import BeautifulSoup as bs
import time

class WorkerThread(QThread):
    stop_signal = pyqtSignal()
    progress_signal = pyqtSignal(str)

    def __init__(self):
        super().__init__()
        self._is_running = True  # 실행 상태
        self._is_paused = False  # 일시 정지 상태

    def run(self):
        for searchIndex, page in self.searchIndexes:
            for p in range(1, page + 1):
                if not self._is_running:  # 실행 중단 확인
                    self.progress_signal.emit("작업 중지")
                    return

                while self._is_paused:  # 일시 정지 상태 대기
                    self.progress_signal.emit("작업 일시 중지 중...")
                    time.sleep(0.1)
                
                # 로직 코드 ...                
                for search in search_list:
                    if not self._is_running:  # 실행 중단 확인
                        self.progress_signal.emit("작업 중지")
                        return

        self.progress_signal.emit("작업 완료")
        self.stop_signal.emit()


    def stop(self):
        self._is_running = False  # 실행 중단

    def pause(self):
        self._is_paused = True  # 작업 일시 정지

    def resume(self):
        self._is_paused = False  # 작업 재개

2. 중지 및 재개 버튼 구현

from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QVBoxLayout, QWidget, QLabel

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        # 버튼 클릭 연결
        self.start_button.clicked.connect(self.start_thread)
        self.pause_button.clicked.connect(self.pause_thread)
        self.resume_button.clicked.connect(self.resume_thread)
        self.stop_button.clicked.connect(self.stop_thread)

        # 초기 값
        self.worker_thread = None

    def pause_thread(self):
        if self.worker_thread and self.worker_thread.isRunning():
            self.worker_thread.pause()
            self.update_status("작업 일시 정지 요청됨")

    def resume_thread(self):
        if self.worker_thread and self.worker_thread.isRunning():
            self.worker_thread.resume()
            self.update_status("작업 재개 요청됨")

    def stop_thread(self):
        if self.worker_thread and self.worker_thread.isRunning():
            self.worker_thread.stop()
            self.worker_thread.wait()
            self.update_status("작업 중지 요청됨")

if __name__ == "__main__":
    app = QApplication([])
    window = MainWindow()
    window.show()
    app.exec()

python