Cách sử dụng QThread trong PyQt

Trong lập trình giao diện đồ họa với PyQt, việc xử lý các tác vụ nặng hoặc kéo dài có thể gây ra hiện tượng giật hoặc treo ứng dụng. Để khắc phục vấn đề này, việc sử dụng QThread là một giải pháp hiệu quả. Bằng cách tách các tác vụ phức tạp sang các luồng xử lý riêng biệt, ứng dụng của bạn có thể vẫn hoạt động mượt mà và phản hồi nhanh trong khi các luồng khác thực hiện công việc. Trong bài viết này, mình sẽ tìm hiểu cách sử dụng QThread trong PyQt để tối ưu hóa hiệu suất và tạo ra các ứng dụng Qt mượt mà hơn.

Giới thiệu về lớp PyQt QThread

Khi một chương trình có các thao tác dài, nó có thể bị giật trong chốc lát, hoặc trong một số trường hợp, chương trình có thể bị đơ hoàn toàn.

Vì vậy, khi phát triển các ứng dụng PyQt, bạn nên biết cách xử lý những tình huống này. Để làm được điều đó, bạn có thể tận dụng đa luồng (threading).

Nếu bạn chưa quen với khái niệm về đa luồng, có thể tìm hiểu thêm trong loạt bài về Concurrency trong Python.

Bài viết này được đăng tại [free tuts .net]

Python cung cấp một số module để xử lý luồng như threading và concurrent.futures.

Mặc dù bạn có thể sử dụng các module này, nhưng PyQt cung cấp một cách tốt hơn thông qua lớp QThread và các lớp khác liên quan.

Luồng chính và luồng phụ

Các ứng dụng Qt dựa trên sự kiện. Khi bạn gọi phương thức exec(), nó sẽ khởi động một vòng lặp sự kiện và tạo ra một luồng được gọi là luồng chính.

Vòng lặp sự kiện PyQt

Các sự kiện xảy ra trong luồng chính sẽ được xử lý đồng bộ trong vòng lặp sự kiện chính này.

Để tận dụng đa luồng, bạn cần tạo một luồng phụ để xử lý các thao tác dài thay vì để chúng thực thi trong luồng chính. Các luồng phụ này thường được gọi là worker threads (luồng công nhân).

Để giao tiếp giữa luồng chính và các luồng phụ, bạn sử dụng tín hiệu và slot. Các bước để sử dụng lớp QThread như sau:

Tạo một lớp thừa kế từ QObject để chuyển các thao tác dài sang lớp này.

class Worker(QObject):
   pass

Chúng ta kế thừa từ lớp QObject vì muốn sử dụng hệ thống signal và slot.

Từ luồng chính, tạo đối tượng worker và luồng worker thread:

self.worker = Worker()
self.worker_thread = QThread()

Biến self ở đây là một instance của QMainWindow hoặc QWidget.

Kết nối các tín hiệu và slot của lớp Worker với luồng chính.

Sau đó, di chuyển worker sang worker thread bằng cách gọi phương thức moveToThread() của đối tượng worker:

self.worker.moveToThread(self.worker_thread)

Cuối cùng, bắt đầu luồng worker:

self.worker_thread.start()

Lưu ý rằng bạn chỉ nên giao tiếp với worker thông qua signal và slot. Không nên gọi trực tiếp các phương thức của nó từ luồng chính. Ví dụ:

self.worker.do_some_work()  # KHÔNG NÊN

Lưu ý rằng một cách khác để sử dụng lớp QThread là thừa kế từ nó và ghi đè phương thức run(). Tuy nhiên, đây không phải là cách được khuyến nghị. Bạn có thể tìm hiểu chi tiết hơn về vấn đề này tại đây.

Ví dụ về QThread trong PyQt

Mình sẽ tạo một chương trình đơn giản sử dụng QThread:

Chương trình có một thanh tiến trình (progress bar) và một nút (button). Khi bạn nhấn nút "Start", quá trình xử lý dài sẽ chạy trên worker thread và cập nhật tiến trình về luồng chính thông qua signal và slot.

import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QWidget, QPushButton, QVBoxLayout, QProgressBar
from PyQt6.QtCore import QThread, QObject, pyqtSignal as Signal, pyqtSlot as Slot
import time

class Worker(QObject):
    progress = Signal(int)
    completed = Signal(int)

    @Slot(int)
    def do_work(self, n):
        for i in range(1, n + 1):
            time.sleep(1)
            self.progress.emit(i)
        self.completed.emit(i)

class MainWindow(QMainWindow):
    work_requested = Signal(int)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setGeometry(100, 100, 300, 100)
        self.setWindowTitle('QThread Demo')

        self.widget = QWidget()
        layout = QVBoxLayout()
        self.widget.setLayout(layout)
        self.setCentralWidget(self.widget)

        self.progress_bar = QProgressBar(self)
        self.progress_bar.setValue(0)

        self.btn_start = QPushButton('Start', clicked=self.start)

        layout.addWidget(self.progress_bar)
        layout.addWidget(self.btn_start)

        self.worker = Worker()
        self.worker_thread = QThread()

        self.worker.progress.connect(self.update_progress)
        self.worker.completed.connect(self.complete)
        self.work_requested.connect(self.worker.do_work)

        self.worker.moveToThread(self.worker_thread)
        self.worker_thread.start()

        self.show()

    def start(self):
        self.btn_start.setEnabled(False)
        n = 5
        self.progress_bar.setMaximum(n)
        self.work_requested.emit(n)

    def update_progress(self, value):
        self.progress_bar.setValue(value)

    def complete(self, value):
        self.progress_bar.setValue(value)
        self.btn_start.setEnabled(True)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = MainWindow()
    sys.exit(app.exec())

Cách hoạt động

Định nghĩa lớp worker

Lớp Worker thừa kế từ QObject để hỗ trợ sử dụng signal và slot. Trong thực tế, bạn sẽ di chuyển các thao tác dài vào lớp Worker:

class Worker(QObject):

Lớp Worker có hai tín hiệu:

• progress: báo cáo tiến độ
• completed: thông báo khi hoàn thành

Các tín hiệu này là các instance của lớp pyqtSignal, vì chúng ta đã import pyqtSignal với tên là Signal, ta có thể sử dụng như sau:

progress = Signal(int)
completed = Signal(int)

Cả hai tín hiệu progress và completed đều chấp nhận một tham số kiểu số nguyên (int).

Lớp Worker phát ra tín hiệu progress khi một phần công việc hoàn thành và tín hiệu completed khi hoàn thành toàn bộ công việc.

Lớp Worker cũng có phương thức do_work():

@Slot(int)
def do_work(self, n):
    for i in range(1, n + 1):
        time.sleep(1)
        self.progress.emit(i)
    self.completed.emit(i)

Phương thức do_work() có sử dụng decorator @Slot() để biến nó thành một slot.

Phương thức do_work() nhận một tham số kiểu số nguyên, và nó sẽ lặp qua một dãy số từ 1 đến giá trị tham số đó. Trong mỗi lần lặp, nó sẽ dừng lại một giây bằng lệnh time.sleep(1) và phát ra tín hiệu progress với giá trị hiện tại. Sau khi hoàn thành, nó sẽ phát ra tín hiệu completed với giá trị cuối cùng.

Giao tiếp giữa luồng chính và worker thread

​Tạo tín hiệu trong lớp MainWindow:

work_requested = Signal(int)

Tạo đối tượng Worker và luồng worker thread:

self.worker = Worker()
self.worker_thread = QThread()

Kết nối các tín hiệu của Worker với các phương thức của MainWindow:

self.worker.progress.connect(self.update_progress)
self.worker.completed.connect(self.complete)

Kết nối tín hiệu work_requested của MainWindow với phương thức do_work của Worker:

self.work_requested.connect(self.worker.do_work)

Di chuyển worker vào worker thread:

self.worker.moveToThread(self.worker_thread)

Bắt đầu worker thread:

self.worker_thread.start()

Kết bài

Qua bài viết này, bạn đã nắm được cách sử dụng QThread để tạo ra các luồng xử lý độc lập (worker thread), giúp chuyển các thao tác dài ra khỏi luồng chính. Điều này đảm bảo ứng dụng luôn phản hồi mượt mà, ngay cả khi phải thực hiện các tác vụ nặng. Bên cạnh đó, việc sử dụng hệ thống signal và slot giúp giao tiếp hiệu quả giữa luồng chính và các worker thread, đảm bảo dữ liệu được cập nhật liên tục mà không gây ảnh hưởng đến hiệu suất chung. Hy vọng bạn có thể áp dụng các kiến thức này để tối ưu hóa ứng dụng PyQt của mình.