请教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的阳

1. QTimer的线程安全问题
在PyQt中，QTimer对象应当与其关联的QObject（如QWidget）在同一线程中创建和使用。由于信号和槽的连接可能跨越线程边界，导致行为不确定或错误。QTimer应当始终在主线程（GUI线程）中创建和管理，即使它的定时事件需要在其他线程中处理。
解决方案
将QTimer放在主线程中，通过信号和槽将定时事件的处理转移到子线程。
2. QTimer在__init__中创建的问题
在__init__中创建QTimer会使其与创建它的线程（通常是主线程）绑定。应当在子线程的run方法中创建并启动QTimer，但正如之前所述，更好的做法是将QTimer放在主线程中。
3. 控制子线程中QTimer的启停
可以通过信号和槽来控制子线程中的任务执行。在子线程中，您可以使用QEventLoop来等待事件，但请注意，QEventLoop应仅在需要时才在子线程中创建，并且通常只应有一个实例。
修改
class PrintThread(QThread):  
    # 移除QTimer相关的属性和方法  
    # ...  
  
    def run(self):  
        # 创建一个工作队列或事件循环  
        self.worker_loop = True  
  
        while self.worker_loop:  
            # 模拟长时间任务  
            sleep(1)  
            print(f'更新数据,时间{datetime.datetime.now()}')  
  
            # 检查是否需要暂停  
            if self.paused.is_set():  
                # 暂停  
                while self.paused.is_set():  
                    sleep(0.1)  # 简短休眠，避免忙等  
  
    # 暂停和恢复方法  
    def pause(self):  
        self.paused.set()  
  
    def resume(self):  
        self.paused.clear()  
  
# 在主窗口类中  
class Mywindow(QWidget):  
    # ...  
    def fun1(self):  
        self.p_thread.pause()  # 发送暂停信号  
        # ...  
        self.p_thread.resume()  # 发送恢复信号  
  
# 主程序保持不变
4. 替代QTimer的方法
使用QTimer与信号槽系统
使用Python标准库中的threading.Timer，但需注意GUI线程的安全
使用asyncio和QEventLoop的集成
5. 优先处理主线程任务
在场景中，主线程执行的任务应当具有高优先级。使用信号和槽来管理子线程的任务执行是一个很好的方式。

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()

复制代码

很cool的阳

去除多余的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

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

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

zhangchenyvn

nsaizl 发表于 2024-8-14 14:09
目前找到一个方法可以实现，但是代码很不好看。有人可以优化一下吗？

这代码挺好的，很完美，没有说“难看”吧

18408238295

刚刚学Python不久，感觉这程序看着很长诶，拆分学习学习，里面提到了类

很cool的阳

nsaizl 发表于 2024-8-16 09:31
为了偷懒，目前也是这样写的。在run方法中加个循环。
但是还是想讨论验证一下QTimer在子线程中运行的 ...

QTimer 是 Qt 提供的一个定时器类，它允许你在指定的时间间隔后执行某些操作。QTimer 的设计初衷是为了在 GUI 应用程序中实现时间相关的功能，比如动画、定时更新等，而不会阻塞主线程的用户界面。

在主线程（通常是 GUI 线程）中使用 QTimer 是非常简单和直接的，因为它自动与主线程的事件循环集成。然而，在子线程中使用 QTimer 就比较复杂，因为每个 QObject（包括 QTimer）都有一个与之关联的线程亲和性（thread affinity），这意味着 QObject 必须在它被创建的线程中执行它的事件和信号槽。因此，你不能在一个线程中创建 QTimer 对象，然后期望它在另一个线程中启动和运行。

在子线程中使用 QTimer 的正确方式是确保 QTimer 对象在该子线程中创建，并且该子线程有一个正在运行的事件循环。这通常是通过继承 QThread 类并重写 run() 方法来实现的，然后在 run() 方法内部创建 QTimer 对象，并调用 QThread::exec() 来启动事件循环。例如：

```cpp
class WorkerThread : public QThread
{
    Q_OBJECT
public:
    WorkerThread() {}
    void run() override {
        QTimer timer;
        timer.setInterval(1000);
        connect(&timer, &QTimer::timeout, this, &WorkerThread::onTimeout);
        timer.start();
        exec(); // 启动事件循环
    }

signals:
    void timeout();
};

void WorkerThread::onTimeout() {
    // 处理定时器超时
    qDebug() << "Timeout in thread:" << QThread::currentThreadId();
}
```

`WorkerThread` 继承自 `QThread`，在它的 `run` 方法中创建了 `QTimer` 对象，并启动了事件循环。这样，定时器就可以在子线程中正常工作了。

player-none

采用这篇文章解释的线程里操作程序

https://fishc.com.cn/thread-248876-1-1.html