devbox
空白诗007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

pyqt5 GUI应用程序多线程（thread）执行多个功能的示例代码_pythongui多线程

作者：空白诗007 | 2024-07-19 23:48:50

赞

踩

pythongui多线程

        下面是使用三个线程，分别由两个按钮控制它启动线程和关闭线程，即每个线程两个按钮，一共六个按钮控制三个线程的启动与关闭的代码实现：

  1. import sys
  2. import time
  3. from PyQt5.QtCore import pyqtSignal, QObject, QThread
  4. from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QPushButton
  5.  
  6.  
  7. # 线程1
  8. class Thread1(QThread):
  9.     signal = pyqtSignal(str)
  10.  
  11.     def __init__(self):
  12.         super().__init__()
  13.         self.running = False
  14.  
  15.     def run(self):
  16.         self.running = True
  17.         while self.running:
  18.             current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
  19.             self.signal.emit(current_time)
  20.             time.sleep(1)
  21.  
  22.     def stop(self):
  23.         self.running = False
  24.  
  25.  
  26. # 线程2
  27. class Thread2(QThread):
  28.     signal = pyqtSignal(str)
  29.  
  30.     def __init__(self):
  31.         super().__init__()
  32.         self.running = False
  33.  
  34.     def run(self):
  35.         self.running = True
  36.         count = 0
  37.         while self.running:
  38.             self.signal.emit(str(count))
  39.             count += 1
  40.             time.sleep(1)
  41.  
  42.     def stop(self):
  43.         self.running = False
  44.  
  45.  
  46. # 线程3
  47. class Thread3(QThread):
  48.     signal = pyqtSignal(str)
  49.  
  50.     def __init__(self):
  51.         super().__init__()
  52.         self.running = False
  53.  
  54.     def run(self):
  55.         self.running = True
  56.         while self.running:
  57.             self.signal.emit('Thread 3 running')
  58.             time.sleep(1)
  59.  
  60.     def stop(self):
  61.         self.running = False
  62.  
  63.  
  64. # GUI界面
  65. class MainWindow(QWidget):
  66.     def __init__(self):
  67.         super().__init__()
  68.  
  69.         self.thread1 = Thread1()
  70.         self.thread2 = Thread2()
  71.         self.thread3 = Thread3()
  72.  
  73.         self.init_ui()
  74.  
  75.     def init_ui(self):
  76.         # 线程1控制按钮
  77.         self.thread1_start_button = QPushButton('启动线程1')
  78.         self.thread1_stop_button = QPushButton('停止线程1')
  79.         self.thread1_start_button.clicked.connect(self.thread1_start)
  80.         self.thread1_stop_button.clicked.connect(self.thread1_stop)
  81.  
  82.         # 线程2控制按钮
  83.         self.thread2_start_button = QPushButton('启动线程2')
  84.         self.thread2_stop_button = QPushButton('停止线程2')
  85.         self.thread2_start_button.clicked.connect(self.thread2_start)
  86.         self.thread2_stop_button.clicked.connect(self.thread2_stop)
  87.  
  88.         # 线程3控制按钮
  89.         self.thread3_start_button = QPushButton('启动线程3')
  90.         self.thread3_stop_button = QPushButton('停止线程3')
  91.         self.thread3_start_button.clicked.connect(self.thread3_start)
  92.         self.thread3_stop_button.clicked.connect(self.thread3_stop)
  93.  
  94.         # 显示结果的标签
  95.         self.thread1_label = QLabel('Thread 1:')
  96.         self.thread1_display_label = QLabel('')
  97.         self.thread2_label = QLabel('Thread 2:')
  98.         self.thread2_display_label = QLabel('')
  99.         self.thread3_label = QLabel('Thread 3:')
  100.         self.thread3_display_label = QLabel('')
  101.  
  102.         layout1 = QHBoxLayout()
  103.         layout1.addWidget(self.thread1_start_button)
  104.         layout1.addWidget(self.thread1_stop_button)
  105.         layout1.addWidget(self.thread1_label)
  106.         layout1.addWidget(self.thread1_display_label)
  107.  
  108.         layout2 = QHBoxLayout()
  109.         layout2.addWidget(self.thread2_start_button)
  110.         layout2.addWidget(self.thread2_stop_button)
  111.         layout2.addWidget(self.thread2_label)
  112.         layout2.addWidget(self.thread2_display_label)
  113.  
  114.         layout3 = QHBoxLayout()
  115.         layout3.addWidget(self.thread3_start_button)
  116.         layout3.addWidget(self.thread3_stop_button)
  117.         layout3.addWidget(self.thread3_label)
  118.         layout3.addWidget(self.thread3_display_label)
  119.  
  120.         main_layout = QVBoxLayout()
  121.         main_layout.addLayout(layout1)
  122.         main_layout.addLayout(layout2)
  123.         main_layout.addLayout(layout3)
  124.  
  125.         self.setLayout(main_layout)
  126.         self.show()
  127.  
  128.     # 线程1控制方法
  129.     def thread1_start(self):
  130.         self.thread1.signal.connect(self.update_thread1_display)
  131.         self.thread1.start()
  132.  
  133.     def thread1_stop(self):
  134.         self.thread1.signal.disconnect()
  135.         self.thread1.stop()
  136.  
  137.     # 线程2控制方法
  138.     def thread2_start(self):
  139.         self.thread2.signal.connect(self.update_thread2_display)
  140.         self.thread2.start()
  141.  
  142.     def thread2_stop(self):
  143.         self.thread2.signal.disconnect()
  144.         self.thread2.stop()
  145.  
  146.     # 线程3控制方法
  147.     def thread3_start(self):
  148.         self.thread3.signal.connect(self.update_thread3_display)
  149.         self.thread3.start()
  150.  
  151.     def thread3_stop(self):
  152.         self.thread3.signal.disconnect()
  153.         self.thread3.stop()
  154.  
  155.     # 更新显示的槽
  156.     def update_thread1_display(self, text):
  157.         self.thread1_display_label.setText(text)
  158.  
  159.     def update_thread2_display(self, text):
  160.         self.thread2_display_label.setText(text)
  161.  
  162.     def update_thread3_display(self, text):
  163.         self.thread3_display_label.setText(text)
  164.  
  165.  
  166. app = QApplication(sys.argv)
  167. window = MainWindow()
  168. sys.exit(app.exec())

        在这个代码中，创建了三个继承自QThread的线程类Thread1、Thread2和Thread3，并分别实现了run()方法和stop()方法。run()方法是在其启动之后，执行的核心代码；stop()方法则用于停止线程。

        在GUI界面中，创建了六个按钮，分别控制三个线程的启动与停止，并将其connect到相应的槽函数上。每个线程的启动与停止通过signal进行连接并实现。

        同时，创建了MainWindow类，并在其中定义了三个线程的实例。在GUI界面创建完毕之后，当用户点击线程启动按钮时，对应的线程会被启动，并将该线程的信号（signal）连接到主窗口的槽（slot）函数，从而更新相应的线程结果展示。

        最后，当用户点击线程停止按钮时，对应的线程会通过disconnect and stop()方法停止，并在主窗口的槽函数中进行反馈。

以上三个线程都没有传递参数，现在将每个线程都传递一个lineedit组件的text参数进去：

  1. import sys
  2. import time
  3. from PyQt5.QtCore import pyqtSignal, QObject, QThread
  4. from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QPushButton
  5.  
  6.  
  7. # 线程1
  8. class Thread1(QThread):
  9.     signal = pyqtSignal(str)
  10.  
  11.     def __init__(self, text):
  12.         super().__init__()
  13.         self.text = text
  14.         self.running = False
  15.  
  16.     def run(self):
  17.         self.running = True
  18.         while self.running:
  19.             current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
  20.             self.signal.emit(f"{current_time} ({self.text})")
  21.             time.sleep(1)
  22.  
  23.     def stop(self):
  24.         self.running = False
  25.  
  26.  
  27. # 线程2
  28. class Thread2(QThread):
  29.     signal = pyqtSignal(str)
  30.  
  31.     def __init__(self, text):
  32.         super().__init__()
  33.         self.text = text
  34.         self.running = False
  35.  
  36.     def run(self):
  37.         self.running = True
  38.         count = 0
  39.         while self.running:
  40.             self.signal.emit(f"{str(count)} ({self.text})")
  41.             count += 1
  42.             time.sleep(1)
  43.  
  44.     def stop(self):
  45.         self.running = False
  46.  
  47.  
  48. # 线程3
  49. class Thread3(QThread):
  50.     signal = pyqtSignal(str)
  51.  
  52.     def __init__(self, text):
  53.         super().__init__()
  54.         self.text = text
  55.         self.running = False
  56.  
  57.     def run(self):
  58.         self.running = True
  59.         while self.running:
  60.             self.signal.emit(f"Thread 3 running ({self.text})")
  61.             time.sleep(1)
  62.  
  63.     def stop(self):
  64.         self.running = False
  65.  
  66.  
  67. # GUI界面
  68. class MainWindow(QWidget):
  69.     def __init__(self):
  70.         super().__init__()
  71.  
  72.         self.thread1 = None
  73.         self.thread2 = None
  74.         self.thread3 = None
  75.  
  76.         self.init_ui()
  77.  
  78.     def init_ui(self):
  79.         # 输入参数的文本框
  80.         self.text_edit = QLineEdit()
  81.  
  82.         # 线程1控制按钮
  83.         self.thread1_start_button = QPushButton('启动线程1')
  84.         self.thread1_stop_button = QPushButton('停止线程1')
  85.         self.thread1_start_button.clicked.connect(self.thread1_start)
  86.         self.thread1_stop_button.clicked.connect(self.thread1_stop)
  87.  
  88.         # 线程2控制按钮
  89.         self.thread2_start_button = QPushButton('启动线程2')
  90.         self.thread2_stop_button = QPushButton('停止线程2')
  91.         self.thread2_start_button.clicked.connect(self.thread2_start)
  92.         self.thread2_stop_button.clicked.connect(self.thread2_stop)
  93.  
  94.         # 线程3控制按钮
  95.         self.thread3_start_button = QPushButton('启动线程3')
  96.         self.thread3_stop_button = QPushButton('停止线程3')
  97.         self.thread3_start_button.clicked.connect(self.thread3_start)
  98.         self.thread3_stop_button.clicked.connect(self.thread3_stop)
  99.  
  100.         # 显示结果的标签
  101.         self.thread1_label = QLabel('Thread 1:')
  102.         self.thread1_display_label = QLabel('')
  103.         self.thread2_label = QLabel('Thread 2:')
  104.         self.thread2_display_label = QLabel('')
  105.         self.thread3_label = QLabel('Thread 3:')
  106.         self.thread3_display_label = QLabel('')
  107.  
  108.         layout1 = QHBoxLayout()
  109.         layout1.addWidget(self.thread1_start_button)
  110.         layout1.addWidget(self.thread1_stop_button)
  111.         layout1.addWidget(self.thread1_label)
  112.         layout1.addWidget(self.thread1_display_label)
  113.  
  114.         layout2 = QHBoxLayout()
  115.         layout2.addWidget(self.thread2_start_button)
  116.         layout2.addWidget(self.thread2_stop_button)
  117.         layout2.addWidget(self.thread2_label)
  118.         layout2.addWidget(self.thread2_display_label)
  119.  
  120.         layout3 = QHBoxLayout()
  121.         layout3.addWidget(self.thread3_start_button)
  122.         layout3.addWidget(self.thread3_stop_button)
  123.         layout3.addWidget(self.thread3_label)
  124.         layout3.addWidget(self.thread3_display_label)
  125.  
  126.         main_layout = QVBoxLayout()
  127.         main_layout.addWidget(self.text_edit)
  128.         main_layout.addLayout(layout1)
  129.         main_layout.addLayout(layout2)
  130.         main_layout.addLayout(layout3)
  131.  
  132.         self.setLayout(main_layout)
  133.         self.show()
  134.  
  135.     # 线程1控制方法
  136.     def thread1_start(self):
  137.         if not self.thread1:
  138.             self.thread1 = Thread1(self.text_edit.text())
  139.             self.thread1.signal.connect(self.update_thread1_display)
  140.             self.thread1.start()
  141.  
  142.     def thread1_stop(self):
  143.         if self.thread1:
  144.             self.thread1.signal.disconnect()
  145.             self.thread1.stop()
  146.             self.thread1 = None
  147.  
  148.     # 线程2控制方法
  149.     def thread2_start(self):
  150.         if not self.thread2:
  151.             self.thread2 = Thread2(self.text_edit.text())
  152.             self.thread2.signal.connect(self.update_thread2_display)
  153.             self.thread2.start()
  154.  
  155.     def thread2_stop(self):
  156.         if self.thread2:
  157.             self.thread2.signal.disconnect()
  158.             self.thread2.stop()
  159.             self.thread2 = None
  160.  
  161.     # 线程3控制方法
  162.     def thread3_start(self):
  163.         if not self.thread3:
  164.             self.thread3 = Thread3(self.text_edit.text())
  165.             self.thread3.signal.connect(self.update_thread3_display)
  166.             self.thread3.start()
  167.  
  168.     def thread3_stop(self):
  169.         if self.thread3:
  170.             self.thread3.signal.disconnect()
  171.             self.thread3.stop()
  172.             self.thread3 = None
  173.  
  174.     # 更新显示的槽
  175.     def update_thread1_display(self, text):
  176.         self.thread1_display_label.setText(text)
  177.  
  178.     def update_thread2_display(self, text):
  179.         self.thread2_display_label.setText(text)
  180.  
  181.     def update_thread3_display(self, text):
  182.         self.thread3_display_label.setText(text)
  183.  
  184.  
  185. app = QApplication(sys.argv)
  186. window = MainWindow()
  187. sys.exit(app.exec())

在这个代码中，我们在创建每个线程实例时，增加了一个参数text来接收lineEdit组件的文本输入。然后在对应的run()方法中，在信号（signal）发射的文本信息后，再加一段括号内容对该参数进行拼接。

GUI界面中，新增了一个QLineEdit组件用于用户输入文本参数，并将其传递给对应的线程实例。同时，为避免重复创建线程实例，我们在启动线程之前检查该线程实例是否已经存在。如果存在，则不再创建新的线程实例。而在停止线程时，我们需要将该线程实例置空。

最后，在更新显示的槽函数中，同样也需要在展示该线程的结果时，将lineedit组件的文本内容显示出来。

PS：以上代码为多线程示例代码，不足之处请引用后自行完善。文章引用请注明出处，谢谢~

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号