前言

在PySide6/PyQT 中使用多线程时，多线程生命周期是一个重要的概念。如果不能正确地管理多线程生命周期，可能会导致程序崩溃、内存泄漏等问题。

在前面的文章中有介绍到 PySide6/PyQT 可以实现多线程的多个类，

有 QObject、QThread、QRunnable、QThreadPool 等

在本篇文章中，着力于介绍多线程的生命周期，而不是实现多线程，所以这里我选择了QThread 来做介绍。

一般来说，我们不用过于关注PySide6/PyQT多线程的生命周期，但是我们需要了解这些概念。

知识点📖📖

本文用到的几个PySide6/PyQT的知识点及链接。

作用	链接
创建新线程	QThread
对象间通信的机制，允许对象发送和接收信号	Signal
用于响应Signal信号的方法	Slot

基础概念

这里使用QThread示例。

在 PySide6/PyQT 多线程的生命周期，有以下六个步骤：

创建线程：使用 QThread 类创建线程实例。
启动线程：调用 start() 方法启动线程，线程会自动调用 run() 方法开始执行。
线程运行：在线程执行期间，可以在 run() 方法中执行需要在子线程中进行的耗时操作。
线程等待：在需要等待线程完成时，可以使用 wait() 方法来阻塞当前线程，直到线程执行完毕。
线程完成：在线程执行完毕后，会自动调用 finished() 信号，表示线程已经完成。
销毁线程：当线程执行完毕后，可以通过 deleteLater() 方法或者 quit() 方法来销毁线程实例。

1.创建线程

重写run()方法，该方法会在新线程中执行

class MyThread(QThread):
    def __init__(self, parent=None):
        super().__init__(parent)
        
    def run(self):
        # 在新线程中执行的代码

2.启动线程

实例化并使用start()启动线程

my_thread = MyThread()
my_thread.start()

3.线程运行

class MyThread(QThread):
    def __init__(self, parent=None):
        super().__init__(parent)
        
    def run(self):
        # 在新线程中执行的代码
        for i in range(10):
            print("Hello from thread:", self.currentThreadId())
            time.sleep(1)

            
my_thread = MyThread()
my_thread.start()
# 打印查看线程是否在运行
print(my_thread.isRunning())

4.线程等待

my_thread = MyThread()
my_thread.start()

# 线程等待，会阻塞当前线程
my_thread.wait()

5.线程完成

my_thread = MyThread()
my_thread.start()

# 打印查看线程是否完成
print(my_thread.isFinished())

6.销毁线程

class MyThread(QThread):
    def __init__(self, parent=None):
        super().__init__(parent)
        
    def run(self):
        # 在新线程中执行的代码
        for i in range(10):
            print("Hello from thread:", self.currentThreadId())
            time.sleep(1)
            
    def stop(self):
        self.quit()
        # 或者使用
        self.deleteLater()
        
    def __del__(self):
        self.wait()

高效管理生命周期

合理管理多线程的生命周期可以避免多线程资源的浪费和泄漏，以及更高效的利用系统资源。

在多线程生命周期中，QThread 与 QThreadPool+QRunnable的差异主要体现在线程的创建和销毁方式。

QThread

需要手动创建和管理线程；
每次调用QThread的start()方法都会创建一个新的线程；
当线程完成任务后，需要手动调用QThread的quit()或deleteLater()方法来销毁线程

QThreadPool + QRunnable

线程的创建和销毁都由QThreadPool来管理；
通过将任务（即实现QRunnable的类）提交给QThreadPool来启动线程，并可以使用QThreadPool的方法来管理线程池中的线程；
线程完成任务后，QThreadPool将自动销毁线程。

所以我推荐使用 QRunnable + QThreadPool 创建多线程，它们是一种更加方便和更友好的实现方式：

更加方便地管理多线程的生命周期；
减少手动管理线程的工作；
有助于避免一些潜在的线程管理问题以及更有效地使用系统资源。

当然，在后面我也还会介绍关于 QThreadPool + QRunnable 的文章。

小技巧

如果需要重复执行相同的任务，我建议只创建一个Thread对象，并在使用时重复调用它的start() 方法。好处如下：

减少系统资源占用：每次创建一个新的线程对象都需要重新的系统资源，而重复使用已有的线程对象可以减少系统资源占用；
提高应用程序的响应速度：每次创建一个新的线程对象都需要一定的时间来分配和初始化资源，而重复使用已有的线程对象则可以减少线程创建和初始化的时间，从而提高应用程序的响应速度；
方便管理线程状态：如果每次创建一个新的线程对象，那么就需要手动管理每个线程的状态，包括启动、暂停、继续、停止等。而如果重复使用已有的线程对象，则可以更方便地管理线程的状态。
…

示例伪代码如下：

from PySide6.QtCore import QThread

class MyThread(QThread):
    def __init__(self):
        super().__init__()

    def run(self):
        # 执行任务的代码

if __name__ == '__main__':
    thread = MyThread()
    thread.start()  # 第一次执行任务
    thread.wait()   # 等待线程完成

    thread.start()  # 第二次执行任务
    thread.wait()   # 等待线程完成

    thread.start()  # 第三次执行任务
    thread.wait()   # 等待线程完成

    # ...

实现

代码示例

# -*- coding: utf-8 -*-

import sys
from PySide6.QtCore import (QThread, Signal, Qt)
from PySide6.QtWidgets import (QApplication, QLabel, QMainWindow, QPushButton, QVBoxLayout, QWidget)


class Worker(QThread):
    finished = Signal()

    def __init__(self):
        super().__init__()

    def run(self):
        print("Thread started")
        for i in range(2):
            print(f"Thread running {i}")
            self.msleep(1000)
        print("Thread finished")
        self.finished.emit()


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setup_ui()
        self.thread = None

    def setup_ui(self):
        central_widget = QWidget(self)
        self.setCentralWidget(central_widget)

        self.label = QLabel("Ready", self)
        self.label.setAlignment(Qt.AlignCenter)

        self.button = QPushButton("Start Thread", self)
        self.button.clicked.connect(self.start_thread)

        layout = QVBoxLayout(central_widget)
        layout.addWidget(self.label)
        layout.addWidget(self.button)
        self.show()

    def start_thread(self):
        if not self.thread or not self.thread.isRunning():
            self.thread = Worker()
            self.thread.finished.connect(self.thread_finished)
            self.thread.start()
            self.label.setText("Running")
            self.thread.wait()

    def thread_finished(self):
        self.label.setText("Finished")
        self.thread.deleteLater()


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

这个案例完整地展示了 PySide6/PyQT 中多线程的生命周期管理，包括线程的创建、启动、运行、等待、结束以及线程对象的销毁。具体体现在以下几个方面：

创建线程对象：代码中通过创建 Worker 类来继承 QThread 类，并在 Worker 类中重写 run() 方法实现多线程执行的逻辑；
启动线程：在主窗口类 MainWindow 中的 start_thread() 方法中，通过创建 Worker 类的实例并调用 start() 方法来启动新的线程；
运行线程：在 run() 方法中，通过使用 msleep() 方法来模拟耗时操作；
线程等待：在start_thread()方法中使用了 self.thread.wait()阻塞当前线程；
结束线程：在 Worker 类的 run() 方法中，当完成耗时操作后，会发送一个 finished 信号，然后线程结束。主窗口类中，可以通过 finished 信号的连接函数 thread_finished() 来在线程结束时进行一些处理；
销毁线程对象：在 thread_finished() 方法中，通过调用 deleteLater() 方法来销毁线程对象，从而保证了线程对象的正确释放。