使用 PyQt 快速搭建带有 GUI 的应用（4）–多线程的使用

王 茂南
王 茂南
王 茂南
3081
文章
75
评论
2021年5月4日07:57:03
评论 11329字阅读37分45秒
摘要本文会介绍 PyQt 中的多线程的使用，防止主界面冻结。同时也会介绍在 PyQt 中的进程池与进程之间的通信，进程锁。

简介

PyQt 应用会有一个主线程来执行 event loop。但是如果你在这个线程上，执行了一个比较长时间的任务，那么主界面会被冻结，直到任务终止。在此期间，用户会无法与程序进行交互，从而会导致糟糕的用户体验。幸运的是，我们可以使用 PyQt 中的 QThread 来解决此问题。

在这一篇文章中，我们会包含以下的内容：

  • 使用 PyQt 的 QThread 来阻止主界面冻结；
  • 使用 QThreadPool 和 QRunnable 创建可重复使用的线程；
  • 使用 signals 和 slots 来管理线程之间的通行；
  • 使用 PyQt 的锁来安全的使用贡献资源；

本文的主要内容参考自，Use PyQt's QThread to Prevent Freezing GUIs。

 

长时间运行的任务

我们首先来看一下长时间运行的任务。长时间运行的任务，会占用 GUI 的主线程，导致应用程序冻结，会导致用户不好的体验。我们来看一下下面的例子：

  1. import sys
  2. from time import sleep
  4. from PyQt5.QtCore import Qt
  5. from PyQt5.QtWidgets import (
  6.     QApplication,
  7.     QLabel,
  8.     QMainWindow,
  9.     QPushButton,
  10.     QVBoxLayout,
  11.     QWidget,
  12. )
  14. class Window(QMainWindow):
  15.     def __init__(self, parent=None):
  16.         super().__init__(parent)
  17.         self.clicksCount = 0
  18.         self.setupUi()
  20.     def setupUi(self):
  21.         """创建主界面
  22.         """
  23.         self.setWindowTitle("Freezing GUI")
  24.         self.resize(300, 150)
  25.         self.centralWidget = QWidget()
  26.         self.setCentralWidget(self.centralWidget)
  27.         # Create and connect widgets
  28.         self.clicksLabel = QLabel("Counting: 0 clicks", self)
  29.         self.clicksLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
  30.         self.stepLabel = QLabel("Long-Running Step: 0")
  31.         self.stepLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
  32.         self.countBtn = QPushButton("Click me!", self)
  33.         self.countBtn.clicked.connect(self.countClicks)
  34.         self.longRunningBtn = QPushButton("Long-Running Task!", self)
  35.         self.longRunningBtn.clicked.connect(self.runLongTask)
  36.         # Set the layout
  37.         layout = QVBoxLayout()
  38.         layout.addWidget(self.clicksLabel)
  39.         layout.addWidget(self.countBtn)
  40.         layout.addStretch()
  41.         layout.addWidget(self.stepLabel)
  42.         layout.addWidget(self.longRunningBtn)
  43.         self.centralWidget.setLayout(layout)
  45.     def countClicks(self):
  46.         self.clicksCount += 1
  47.         self.clicksLabel.setText(f"Counting: {self.clicksCount} clicks")
  49.     def reportProgress(self, n):
  50.         self.stepLabel.setText(f"Long-Running Step: {n}")
  52.     def runLongTask(self):
  53.         """Long-running task in 5 steps."""
  54.         for i in range(5):
  55.             sleep(1)
  56.             self.reportProgress(i + 1)
  58. app = QApplication(sys.argv)
  59. win = Window()
  60. win.show()
  61. sys.exit(app.exec())

上面的 GUI 会包含两个按钮：

  • Click me!，点击会运行一个短时间的任务。
  • Long-Running Task!，点击会运行一个长时间的任务。上面的代码中包含 sleep，所以会等 5 秒才会发生变化。我们在循环中，会去改变 label 的值。但是在实际运行中，我们发现界面上的数字没有实时改变，而是在运行结束之后，直接变为了数字 5.
使用 PyQt 快速搭建带有 GUI 的应用（4）–多线程的使用

为了解决这个主界面冻结的问题，我们后面会使用 QThread 来进行解决。

 

PyQt 中的 QThread

PyQt 中可以使用 QThread 来创建多线程的应用。PyQt 中包含两种不同的线程，分别是：

  • Main Thread：一个应用的 main thread 是一直存在的，应用的主界面就是通过这个线程显示的。当执行 .exec() 的时候开始这个线程。这个线程会管理所有的窗口，以及与主机进行通行。
  • Worker Thread：我们可以创建许多的 worker thread。work thread 可以运行长时间的任务，防止主线程被长时间的任务占用。

我们使用 QThread 来解决上面的问题。主要有下面的几个步骤：

  1. 使用 QObject 初始化一个类，将长时间的任务放在里面；
  2. 将上面的类实例化，得到 worker；
  3. 实例化一个 QThread，thread = QThread()；
  4. 将上面的 worker 移动到新创建的线程中，使用 .moveToThread(thread) 进行移动
  5. 连接所需要的信号和插槽，保持通信；
  6. 调用 QThread 中的 .start；

我们对上面的代码进行修改，得到如下的代码（修改的地方均加上了注释）：

  1. import sys
  2. from time import sleep
  4. from PyQt5.QtCore import QObject, QThread, pyqtSignal # 需要导入这些库
  5. from PyQt5.QtCore import Qt
  6. from PyQt5.QtWidgets import (
  7.     QApplication,
  8.     QLabel,
  9.     QMainWindow,
  10.     QPushButton,
  11.     QVBoxLayout,
  12.     QWidget,
  13. )
  15. # Step 1: Create a worker class
  16. class Worker(QObject):
  17.     finished = pyqtSignal() # 结束的信号
  18.     progress = pyqtSignal(int)
  20.     def run(self):
  21.         """Long-running task."""
  22.         for i in range(5):
  23.             sleep(1)
  24.             self.progress.emit(i + 1) # 发出表示进度的信号
  25.         self.finished.emit() # 发出结束的信号
  27. class Window(QMainWindow):
  28.     def __init__(self, parent=None):
  29.         super().__init__(parent)
  30.         self.clicksCount = 0
  31.         self.setupUi()
  33.     def setupUi(self):
  34.         """创建主界面
  35.         """
  36.         self.setWindowTitle("Freezing GUI")
  37.         self.resize(300, 150)
  38.         self.centralWidget = QWidget()
  39.         self.setCentralWidget(self.centralWidget)
  40.         # Create and connect widgets
  41.         self.clicksLabel = QLabel("Counting: 0 clicks", self)
  42.         self.clicksLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
  43.         self.stepLabel = QLabel("Long-Running Step: 0")
  44.         self.stepLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
  45.         self.countBtn = QPushButton("Click me!", self)
  46.         self.countBtn.clicked.connect(self.countClicks)
  47.         self.longRunningBtn = QPushButton("Long-Running Task!", self)
  48.         self.longRunningBtn.clicked.connect(self.runLongTask)
  49.         # Set the layout
  50.         layout = QVBoxLayout()
  51.         layout.addWidget(self.clicksLabel)
  52.         layout.addWidget(self.countBtn)
  53.         layout.addStretch()
  54.         layout.addWidget(self.stepLabel)
  55.         layout.addWidget(self.longRunningBtn)
  56.         self.centralWidget.setLayout(layout)
  58.     def countClicks(self):
  59.         self.clicksCount += 1
  60.         self.clicksLabel.setText(f"Counting: {self.clicksCount} clicks")
  62.     def reportProgress(self, n):
  63.         self.stepLabel.setText(f"Long-Running Step: {n}")
  65.     def runLongTask(self):
  66.         """修改复杂任务的函数
  67.         """
  68.         # Step 2: Create a QThread object
  69.         self.thread = QThread()
  70.         # Step 3: Create a worker object
  71.         self.worker = Worker()
  72.         # Step 4: Move worker to the thread
  73.         self.worker.moveToThread(self.thread)
  74.         # Step 5: Connect signals and slots
  75.         self.thread.started.connect(self.worker.run) # 通知开始
  76.         self.worker.finished.connect(self.thread.quit) # 结束后通知结束
  77.         self.worker.finished.connect(self.worker.deleteLater) # 完成后删除对象
  78.         self.thread.finished.connect(self.thread.deleteLater) # 完成后删除对象
  79.         self.worker.progress.connect(self.reportProgress) # 绑定 progress 的信号
  80.         # Step 6: Start the thread
  81.         self.thread.start()
  83.         # Final resets (结束的时候做的事)
  84.         self.longRunningBtn.setEnabled(False) # 将按钮设置为不可点击
  85.         self.thread.finished.connect(
  86.             lambda: self.longRunningBtn.setEnabled(True)
  87.         )
  88.         self.thread.finished.connect(
  89.             lambda: self.stepLabel.setText("Long-Running Step: 0")
  90.         )
  92. app = QApplication(sys.argv)
  93. win = Window()
  94. win.show()
  95. sys.exit(app.exec())

在上面的代码中，我们将所有需要长时间运行的代码均放在 .runLongTask 中。循环会发出 progress 信号，该信号表示操作的进度。最后 .runLongTask() 发出 finsihed 信号表示已经处理完成。接着使用 connect 将这些信号连接到不同的插槽上。例如将 progress 连接到 reportProgress 上面，可以在 GUI 上改变数字。

最终的实验结果如下所示，可以看到点击之后，界面上数字可以实时变动：

使用 PyQt 快速搭建带有 GUI 的应用（4）–多线程的使用

 

 

重复使用线程-QRunnable 与 QThreadPool

如果我们的应用程序严重依赖多线程，那么我们会面临大量创建和销毁线程，同时需要考虑需要启动多少线程，PyQt 对此也提供了相应的解决方案，可以使用全局线程池，QThreadPool。

全局线程池会根据当前 CPU 中内核数来维护和管理建议的线程数。池中的线程是可以重复利用的，从而避免了创建和销毁线程相关的开销。我们基于 QRunnable 来创建子类，并在 run 中定义需要长时间运行的代码。下面是一个例子：

  1. import logging
  2. import random
  3. import sys
  4. import time
  6. from PyQt5.QtCore import QRunnable, Qt, QThreadPool
  7. from PyQt5.QtWidgets import (
  8.     QApplication,
  9.     QLabel,
  10.     QMainWindow,
  11.     QPushButton,
  12.     QVBoxLayout,
  13.     QWidget,
  14. )
  16. logging.basicConfig(format="%(message)s", level=logging.INFO)
  18. # 1. Subclass QRunnable
  19. class Runnable(QRunnable):
  20.     def __init__(self, n):
  21.         super().__init__()
  22.         self.n = n
  24.     def run(self):
  25.         # Your long-running task goes here ... (需要放在 run 这个函数里)
  26.         for i in range(5):
  27.             logging.info(f"Working in thread {self.n}, step {i + 1}/5")
  28.             time.sleep(random.randint(700, 2500) / 1000)
  30. class Window(QMainWindow):
  31.     def __init__(self, parent=None):
  32.         super().__init__(parent)
  33.         self.setupUi()
  35.     def setupUi(self):
  36.         self.setWindowTitle("QThreadPool + QRunnable")
  37.         self.resize(250, 150)
  38.         self.centralWidget = QWidget()
  39.         self.setCentralWidget(self.centralWidget)
  40.         # Create and connect widgets
  41.         self.label = QLabel("Hello, World!")
  42.         self.label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
  43.         countBtn = QPushButton("Click me!")
  44.         countBtn.clicked.connect(self.runTasks)
  45.         # Set the layout
  46.         layout = QVBoxLayout()
  47.         layout.addWidget(self.label)
  48.         layout.addWidget(countBtn)
  49.         self.centralWidget.setLayout(layout)
  51.     def runTasks(self):
  52.         threadCount = QThreadPool.globalInstance().maxThreadCount() # 设置最大线程数
  53.         self.label.setText(f"Running {threadCount} Threads") # 更新 label 有多少线程
  54.         pool = QThreadPool.globalInstance()
  55.         for i in range(threadCount):
  56.             # 2. Instantiate the subclass of QRunnable
  57.             runnable = Runnable(i) # 实例化 Runnable, 使用 i 来标识当前的线程, 
  58.             # 3. Call start()
  59.             pool.start(runnable) # 在线程池中进行 start
  61. app = QApplication(sys.argv)
  62. window = Window()
  63. window.show()
  64. sys.exit(app.exec())

运算上面的代码出现如下的界面。点击 Click me! 可以看到启动了四个线程。

使用 PyQt 快速搭建带有 GUI 的应用（4）–多线程的使用

使用QThreadPool和QRunnable有一个缺点，也就是基于QRunnable的类不支持信号和插槽，因此线程间通信可能具有挑战性。

 

线程之间的通信

上面我们介绍了如何使用 QThread 来使用多线程。有的时候线程之间需要建立通信，例如将数据发送到线程，更新主界面等。PyQt 中的信号与插槽的机制可以方便的建立通信。

如果多个线程同时访问同一数据或资源，并且其中至少有一个写入或修改此共享资源，那么您可能会遇到崩溃，内存或数据损坏，死锁或其他问题。我们可以使用互斥（Mutual Exclusion）来解决上面的问题。它使用锁来保护对数据和资源的访问。锁是一种同步机制，通常只允许一个线程在给定时间访问资源。例如在 PyQt 中可以使用 QMutex。

下面我们来看一个例子。现在有一个银行账户存有 100 元。两个人同时从这个账户中取出 60 元，如果没有锁，那么最终账户的余额为 -20，这是不可以的。

  1. import logging
  2. import sys
  3. from time import sleep
  5. from PyQt5.QtCore import QMutex, QObject, QThread, pyqtSignal
  6. from PyQt5.QtWidgets import (
  7.     QApplication,
  8.     QLabel,
  9.     QMainWindow,
  10.     QPushButton,
  11.     QVBoxLayout,
  12.     QWidget,
  13. )
  15. logging.basicConfig(format="%(message)s", level=logging.INFO)
  17. balance = 100.00 # 账户余额
  18. mutex = QMutex() # 防止 balance 被多个线程同时访问
  20. class AccountManager(QObject):
  21.     finished = pyqtSignal() # 结束的信号
  22.     updatedBalance = pyqtSignal()
  24.     def withdraw(self, person, amount):
  25.         logging.info("%s wants to withdraw $%.2f...", person, amount)
  26.         global balance
  27.         mutex.lock() # 锁定
  28.         if balance - amount >= 0:
  29.             sleep(1)
  30.             balance -= amount
  31.             logging.info("-$%.2f accepted", amount)
  32.         else:
  33.             logging.info("-$%.2f rejected", amount)
  34.         logging.info("===Balance===: $%.2f", balance)
  35.         self.updatedBalance.emit()
  36.         mutex.unlock() # 解锁
  37.         self.finished.emit()
  39. class Window(QMainWindow):
  40.     def __init__(self, parent=None):
  41.         super().__init__(parent)
  42.         self.setupUi()
  43.         self.threads = []
  45.     def setupUi(self):
  46.         """创建 GUI 需要的代码
  47.         """
  48.         self.setWindowTitle("Account Manager")
  49.         self.resize(200, 150)
  50.         self.centralWidget = QWidget()
  51.         self.setCentralWidget(self.centralWidget)
  52.         button = QPushButton("Withdraw Money!")
  53.         button.clicked.connect(self.startThreads) # 绑定按钮
  54.         self.balanceLabel = QLabel(f"Current Balance: ${balance:,.2f}")
  55.         layout = QVBoxLayout()
  56.         layout.addWidget(self.balanceLabel)
  57.         layout.addWidget(button)
  58.         self.centralWidget.setLayout(layout)
  60.     def updateBalance(self):
  61.         """更新余额的显示
  62.         """
  63.         self.balanceLabel.setText(f"Current Balance: ${balance:,.2f}")
  65.     def createThread(self, person, amount):
  66.         """某一个人开始取钱
  68.         Args:
  69.             person (str): 人名
  70.             amount (float): 取钱的金额
  71.         """
  72.         thread = QThread()
  73.         worker = AccountManager()
  74.         worker.moveToThread(thread)
  75.         thread.started.connect(lambda: worker.withdraw(person, amount)) # 将 start 与 withdraw 连起来
  76.         worker.updatedBalance.connect(self.updateBalance)
  77.         worker.finished.connect(thread.quit)
  78.         worker.finished.connect(worker.deleteLater)
  79.         thread.finished.connect(thread.deleteLater)
  80.         return thread
  82.     def startThreads(self):
  83.         self.threads.clear()
  84.         people = {
  85.             "Alice": 60,
  86.             "Bob": 60,
  87.         }
  88.         self.threads = [self.createThread(person, amount) for person, amount in people.items()] # 为每个人创建一个线程
  89.         for thread in self.threads:
  90.             thread.start() # 开始线程
  93. app = QApplication(sys.argv)
  94. window = Window()
  95. window.show()
  96. sys.exit(app.exec())

我们运行上面的代码，会有如下的运行效果，可以看到第二个人会取钱失败，提示余额不足：

使用 PyQt 快速搭建带有 GUI 的应用（4）–多线程的使用

  • 微信公众号
  • 关注微信公众号
  • weinxin
  • QQ群
  • 我们的QQ群号
  • weinxin
王 茂南
  • 本文由 发表于 2021年5月4日07:57:03
  • 转载请务必保留本文链接：https://mathpretty.com/13641.html
匿名

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: