[已解决]请教pyqt5子线程内使用QTimer循环运行长耗时函数的问题

nsaizl

直接上代码

1. from PyQt5.QtCore import pyqtSignal, pyqtSlot, QThread, QTimer
   
2. from PyQt5.QtWidgets import QApplication, QWidget
   
3. from PyQt5 import uic
   
4. import sys
   
5. import datetime
   
6. import threading
   
7. from time import sleep
   
8. 
   
9. class PrintThread(QThread):
   
10.     resSignal = pyqtSignal(str , str)
    
11. 
    
12.     def __init__(self):
    
13.         super().__init__()
    
14.         self.p_timer = None
    
15.         self.paused = threading.Event()
    
16.         self.paused.set()
    
17. 
    
18.     def run(self):
    
19.         self.p_timer = QTimer()
    
20.         self.p_timer.moveToThread(self)
    
21.         self.p_timer.setInterval(1000)
    
22.         self.p_timer.timeout.connect(self.query_and_print)
    
23.         self.exec_()
    
24. 
    
25.     @pyqtSlot()
    
26.     def query_and_print(self):
    
27.         print(f'更新数据,时间{datetime.datetime.now()}')
    
28. 
    
29.     @pyqtSlot()
    
30.     def pause(self):
    
31.         self.paused.clear()
    
32.         if self.p_timer.isActive():
    
33.             self.p_timer.stop()  # 停止定时器
    
34.         print("定时器已暂停")
    
35. 
    
36.     @pyqtSlot()
    
37.     def resume(self):
    
38.         print('恢复定时器')
    
39.         if not self.p_timer.isActive():
    
40.             self.p_timer.start(1000)  # 重新启动定时器
    
41.         self.paused.set()
    
42.         print("定时器已恢复")
    
43. 
    
44. class Mywindow(QWidget):
    
45.     pauseSignal = pyqtSignal()
    
46.     resumeSignal = pyqtSignal()
    
47. 
    
48.     def __init__(self):
    
49.         super().__init__()
    
50.         self.init_ui()
    
51. 
    
52.         self.p_thread = PrintThread()
    
53.         self.p_thread.resSignal.connect(self.update_to_mysql)
    
54.         self.pauseSignal.connect(self.p_thread.pause)
    
55.         self.resumeSignal.connect(self.p_thread.resume)
    
56.         self.p_thread.start()
    
57. 
    
58.     def fun1(self):
    
59.         self.pauseSignal.emit()  # 发送暂停信号
    
60.         for i in range(3):
    
61.             sleep(1)
    
62.             print(f'正在运行{i}')
    
63.         self.resumeSignal.emit()  # 发送恢复信号
    
64. 
    
65.     def init_ui(self):
    
66.         self.ui = uic.loadUi("./测试.ui") #这里面只有一个按钮
    
67.         self.btn1 = self.ui.pushButton
    
68.         self.btn1.clicked.connect(self.fun1)
    
69. 
    
70.     def update_to_mysql(self):
    
71.         pass
    
72. 
    
73. if __name__ == "__main__":
    
74.     app = QApplication(sys.argv)
    
75.     w = Mywindow()
    
76.     w.ui.show()
    
77.     app.exec()

复制代码

有以下几个问题：
1、self.p_timer = QTimer() 是在子线程中创建的，但是由子线程的中调用pause()函数调用self.p_timer.stop()时会报错，提示不能从其他线程停止QTimer。使用threading.get_ident()后发现pause()函数运行时的确与子线程的ID不同，与主线程是一致的。请问是什么原因？
2、如果将self.p_timer = QTimer() 放到子线程的init()中，那么主线程创建实例时就生成了计时器，所用的线程还是主线程，没有达到多线程运行的目的。对于长时间的函数query_and_print()依然会阻塞主界面。如果一定要这么做，有什么解决的办法？或者说明肯定不能放在init里面的原因。
3、子线程PrintThread中的run函数，如果创建了p_timer = QTimer() ，不使用self，直接connect一个run函数里面的子函数，是可以在子线程中运行的，也可以控制QTimer的启停比如

1.     def run(self):
   
2.         a = 0
   
3.         def query_and_print():
   
4.             nonlocal a
   
5.             print(f'更新数据,时间{datetime.datetime.now()}')
   
6.             sleep(1)
   
7.             a += 1
   
8.             if a == 3:
   
9.                 p_timer.stop()
   
10. 
    
11.         loop = QEventLoop()
    
12.         p_timer = QTimer()
    
13.         p_timer.setInterval(1000)
    
14.         p_timer.timeout.connect(query_and_print)
    
15.         p_timer.start()
    
16.         loop.exec_()

复制代码

在这个情况下，怎么从主界面通过按钮发送信号控制子线程中QTimer的暂停与启动。
4、除了在子线程中用while循环模拟QTimer行为，还有没有别的好方法？
5、最终目的是在主线程中调用fun1()时，先暂停子线程的计时器（因为计时器调用的函数会使用另外一个app，必须确保主线程使用该app时的优先性），然后等主线程运行完毕后再由子线程接管这个app。有没有更好的解决办法？

最佳答案

月排行榜 / 总排行榜

很cool的阳

2024-8-13 23:22:31

去除多余的QEventLoop和QTimer管理：直接使用QThread的run方法循环，并通过条件变量来控制暂停和恢复。
简化信号和槽的使用：直接在QThread中使用pyqtSignal来控制状态，无需额外的emit_函数。
移除不必要的threading.Event：QThread的isRunning方法已经足够用来判断线程是否在运行，结合条件变量（虽然在这个简单示例中未直接使用，但可以通过QMutex和QWaitCondition来实现更复杂的同步）。
以下是优化后的代码：
from PyQt5.QtCore import pyqtSignal, QThread, Qt  
from PyQt5.QtWidgets import QApplication, QWidget  
from PyQt5 import uic  
import sys  
import time  
  
class PrintThread(QThread):  
    pauseSignal = pyqtSignal()  
    resumeSignal = pyqtSignal()  
  
    def __init__(self):  
        super().__init__()  
        self.paused = False  
  
    def run(self):  
        while True:  
            if self.paused:  
                time.sleep(0.1)  # 简单轮询检查暂停状态  
                continue  
              
            print(f"打印: {time.ctime()}")  
            time.sleep(1)  # 模拟查询和打印操作  
  
    def pause(self):  
        self.paused = True  
        self.pauseSignal.emit()  
  
    def resume(self):  
        self.paused = False  
        self.resumeSignal.emit()  
  
class MyWindow(QWidget):  
    def __init__(self):  
        super().__init__()  
        self.init_ui()  
  
        self.p_thread = PrintThread()  
        self.p_thread.start()  
  
    def fun1(self):  
        self.p_thread.pause()  
  
        print(f"发送暂停信号: {time.ctime()}")  
        for i in range(10):  
            time.sleep(1)  
            print(f'主线程正在运行: {i}')  
  
        self.p_thread.resume()  
  
    def init_ui(self):  
        self.ui = uic.loadUi("./测试.ui")  
        self.btn1 = self.ui.pushButton  
        self.btn1.clicked.connect(self.fun1)  
  
if __name__ == "__main__":  
    app = QApplication(sys.argv)  
    w = MyWindow()  
    w.ui.show()  
    app.exec_()

跳转到最佳答案楼层

nsaizl

目前找到一个方法可以实现，但是代码很不好看。有人可以优化一下吗？

1. from PyQt5.QtCore import pyqtSignal, pyqtSlot, QThread, QTimer, QEventLoop, QMetaObject, Qt, Q_ARG
   
2. from PyQt5.QtWidgets import QApplication, QWidget
   
3. from PyQt5 import uic
   
4. import sys
   
5. import datetime
   
6. import threading
   
7. from time import sleep
   
8. import os
   
9. 
   
10. class PrintThread(QThread):
    
11.     resSignal = pyqtSignal(str , str)
    
12.     pauseSignal = pyqtSignal()
    
13.     resumeSignal = pyqtSignal()
    
14. 
    
15.     def __init__(self):
    
16.         super().__init__()
    
17.         self.paused = threading.Event()
    
18.         self.paused.set()
    
19.         self.a = 0
    
20. 
    
21.     def run(self):
    
22.         def query_and_print():
    
23.             print(f"#query_and_print线程ID: {threading.get_ident()},时间{datetime.datetime.now()}")
    
24.             if not self.paused.is_set():
    
25.                 return
    
26.             sleep(1)
    
27. 
    
28.         def pause():
    
29.             if self.p_timer and self.p_timer.isActive():
    
30.                 print(f"暂停时的ID: {threading.get_ident()}")
    
31.                 self.p_timer.stop()  # 停止定时器
    
32.                 print("定时器已暂停")  
    
33. 
    
34.         def resume():
    
35.             if not self.p_timer.isActive():
    
36.                 print(f"恢复时的ID: {threading.get_ident()}")
    
37.                 self.p_timer.start()  # 重新启动定时器
    
38.             self.paused.set()
    
39.             print("定时器已恢复")  
    
40. 
    
41.         loop = QEventLoop()
    
42.         # 连接pauseSignal到pause函数
    
43.         self.pauseSignal.connect(pause)
    
44.         self.resumeSignal.connect(resume)
    
45. 
    
46.         print(f"子线程ID: {threading.get_ident()}")
    
47.         self.p_timer = QTimer()
    
48.         self.p_timer.setInterval(1000)
    
49.         self.p_timer.timeout.connect(query_and_print)
    
50. 
    
51.         #只启动一次
    
52.         if self.a == 0:
    
53.             self.p_timer.start()
    
54.             self.a = 1
    
55. 
    
56.         loop.exec_()  # 启动事件循环
    
57. 
    
58.     @pyqtSlot()
    
59.     def emit_pause_signal(self):
    
60.         # 在子线程中发射暂停信号
    
61.         self.pauseSignal.emit()
    
62. 
    
63.     def request_pause(self):
    
64.         # 从主线程调用这个方法来请求暂停
    
65.         QMetaObject.invokeMethod(self, "emit_pause_signal", Qt.DirectConnection)
    
66. 
    
67.     @pyqtSlot()
    
68.     def emit_resume_signal(self):
    
69.         # 在子线程中发射暂停信号
    
70.         self.resumeSignal.emit()
    
71. 
    
72.     def request_resume(self):
    
73.         # 从主线程调用这个方法来请求运行
    
74.         QMetaObject.invokeMethod(self, "emit_resume_signal", Qt.DirectConnection)
    
75. 
    
76. 
    
77. class Mywindow(QWidget):
    
78. 
    
79.     def __init__(self):
    
80.         super().__init__()
    
81.         self.init_ui()
    
82. 
    
83.         print(f"主线程ID: {threading.get_ident()}")
    
84. 
    
85.         self.p_thread = PrintThread()
    
86.         self.p_thread.resSignal.connect(self.update_to_mysql)
    
87.         self.p_thread.start()
    
88. 
    
89.     def fun1(self):
    
90.         self.p_thread.request_pause()
    
91. 
    
92.         print(f"发送暂停信号的线程ID: {threading.get_ident()}")
    
93.         for i in range(10):
    
94.             sleep(1)
    
95.             print(f'正在运行{i}')
    
96. 
    
97.         self.p_thread.request_resume()
    
98. 
    
99. 
    
100.     def init_ui(self):
     
101.         self.ui = uic.loadUi("./测试.ui")
     
102.         self.btn1 = self.ui.pushButton
     
103.         self.btn1.clicked.connect(self.fun1)
     
104. 
     
105.     def update_to_mysql(self):
     
106.         pass
     
107. 
     
108. if __name__ == "__main__":
     
109.     app = QApplication(sys.argv)
     
110.     w = Mywindow()
     
111.     w.ui.show()
     
112.     app.exec()

复制代码

nsaizl

很cool的阳 发表于 2024-8-15 14:43
去除多余的QEventLoop和QTimer管理：直接使用QThread的run方法循环，并通过条件变量来控制暂停和恢复。
简 ...

为了偷懒，目前也是这样写的。在run方法中加个循环。
但是还是想讨论验证一下QTimer在子线程中运行的逻辑。这玩意设计的初衷是什么？为什么在子线程中这么不好用。