如何更改 Qthread 内 Qtimer 的间隔？

Question

我希望能够在 QThread 中更改 QTimer 的间隔时间。这是我的代码。

import sys
from PyQt5 import QtWidgets
from PyQt5.QtWidgets import QApplication, QMainWindow
from PyQt5.QtCore import QObject, QTimer, QThread


class Worker(QObject):
    def __init__(self):
        QObject.__init__(self)
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.work)

    def start(self):
        self.timer.start(1000)

    def work(self):
        print("Hello World...")

    def set_interval(self, interval):
        self.timer.setInterval(interval)


def main():
    # Set up main window
    app = QApplication(sys.argv)
    win = QMainWindow()
    win.setFixedSize(200, 100)
    spinbox_interval = QtWidgets.QSpinBox(win)
    spinbox_interval.setMaximum(5000)
    spinbox_interval.setSingleStep(500)
    spinbox_interval.setValue(1000)

    worker = Worker()
    thread = QThread()
    worker.moveToThread(thread)
    thread.started.connect(worker.start)
    thread.start()

    def change_interval():
        value = spinbox_interval.value()
        worker.set_interval(value)

    spinbox_interval.valueChanged.connect(change_interval)

    win.show()
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()

如果我在启动定时器后调用worker.setInterval()，超时信号不再发出信号。有人可以向我解释我做错了什么吗？

Answer 1

要了解问题，您必须运行在控制台/CMD 中获取错误消息，从而了解原因，如果这样做，您会收到以下错误消息：

QObject::killTimer: Timers cannot be stopped from another thread
QObject::startTimer: Timers cannot be started from another thread

要理解此错误消息，您必须知道：

QObject 不是线程安全的，因此不能从另一个线程修改它们，
QObject 的子对象与父对象在同一个线程中。

因此，作为 Worker 的子项的计时器将作为其父项存在于辅助线程中，因此您无法从另一个线程修改它。本例是在副线程中发送修改信息，为此有几种选择：

QMetaObject.invokeMethod() 与 pyqtSlot:

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QSpinBox
from PyQt5.QtCore import pyqtSlot, QMetaObject, QObject, Qt, QTimer, QThread, Q_ARG


class Worker(QObject):
    def __init__(self):
        QObject.__init__(self)
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.work)

    def start(self):
        self.timer.start(1000)

    def work(self):
        print("Hello World...")

    @pyqtSlot(int)
    def set_interval(self, interval):
        self.timer.setInterval(interval)


def main():
    # Set up main window
    app = QApplication(sys.argv)
    win = QMainWindow()
    win.setFixedSize(200, 100)
    spinbox_interval = QSpinBox(win)
    spinbox_interval.setMaximum(5000)
    spinbox_interval.setSingleStep(500)
    spinbox_interval.setValue(1000)

    worker = Worker()
    thread = QThread()
    worker.moveToThread(thread)
    thread.started.connect(worker.start)
    thread.start()

    def change_interval():
        value = spinbox_interval.value()
        QMetaObject.invokeMethod(
            worker, "set_interval", Qt.QueuedConnection, Q_ARG(int, value)
        )

    spinbox_interval.valueChanged.connect(change_interval)

    win.show()
    ret = app.exec_()

    QMetaObject.invokeMethod(worker.timer, "stop")
    thread.quit()
    thread.wait()
    sys.exit(ret)


if __name__ == "__main__":
    main()

带插槽的自定义信号：

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QSpinBox
from PyQt5.QtCore import pyqtSignal, pyqtSlot, QMetaObject, QObject, Qt, QTimer, QThread


class Worker(QObject):
    updateInterval = pyqtSignal(int)

    def __init__(self):
        QObject.__init__(self)
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.work)

        self.updateInterval.connect(self.set_interval)

    def start(self):
        self.timer.start(1000)

    def work(self):
        print("Hello World...")

    @pyqtSlot(int)
    def set_interval(self, interval):
        self.timer.setInterval(interval)


def main():
    # Set up main window
    app = QApplication(sys.argv)
    win = QMainWindow()
    win.setFixedSize(200, 100)
    spinbox_interval = QSpinBox(win)
    spinbox_interval.setMaximum(5000)
    spinbox_interval.setSingleStep(500)
    spinbox_interval.setValue(1000)

    worker = Worker()
    thread = QThread()
    worker.moveToThread(thread)
    thread.started.connect(worker.start)
    thread.start()

    def change_interval():
        value = spinbox_interval.value()
        worker.updateInterval.emit(value)

    spinbox_interval.valueChanged.connect(change_interval)

    win.show()
    ret = app.exec_()

    QMetaObject.invokeMethod(worker.timer, "stop")
    thread.quit()
    thread.wait()
    sys.exit(ret)


if __name__ == "__main__":
    main()

自定义 QEvent:

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QSpinBox
from PyQt5.QtCore import QEvent, QMetaObject, QObject, Qt, QTimer, QThread


class IntervalEvent(QEvent):
    def __init__(self, interval):
        QEvent.__init__(self, QEvent.User + 1000)
        self._interval = interval

    @property
    def interval(self):
        return self._interval


class Worker(QObject):
    def __init__(self):
        QObject.__init__(self)
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.work)

    def start(self):
        self.timer.start(1000)

    def work(self):
        print("Hello World...")

    def set_interval(self, interval):
        self.timer.setInterval(interval)

    def event(self, e):
        if isinstance(e, IntervalEvent):
            self.set_interval(e.interval)
        return Worker.event(self, e)


def main():
    # Set up main window
    app = QApplication(sys.argv)
    win = QMainWindow()
    win.setFixedSize(200, 100)
    spinbox_interval = QSpinBox(win)
    spinbox_interval.setMaximum(5000)
    spinbox_interval.setSingleStep(500)
    spinbox_interval.setValue(1000)

    worker = Worker()
    thread = QThread()
    worker.moveToThread(thread)
    thread.started.connect(worker.start)
    thread.start()

    def change_interval():
        value = spinbox_interval.value()
        event = IntervalEvent(value)
        QApplication.postEvent(worker, event)

    spinbox_interval.valueChanged.connect(change_interval)

    win.show()
    ret = app.exec_()

    QMetaObject.invokeMethod(worker.timer, "stop")
    thread.quit()
    thread.wait()
    sys.exit(ret)


if __name__ == "__main__":
    main()

QTimer.singleShot() 与 functools.partial()（仅适用于 PyQt5，不适用于 PySide2）

import sys
from functools import partial

from PyQt5.QtWidgets import QApplication, QMainWindow, QSpinBox
from PyQt5.QtCore import QMetaObject, QObject, Qt, QTimer, QThread


class Worker(QObject):
    def __init__(self):
        QObject.__init__(self)
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.work)

    def start(self):
        self.timer.start(1000)

    def work(self):
        print("Hello World...")

    def set_interval(self, interval):
        print(interval)
        self.timer.setInterval(interval)


def main():
    # Set up main window
    app = QApplication(sys.argv)
    win = QMainWindow()
    win.setFixedSize(200, 100)
    spinbox_interval = QSpinBox(win)
    spinbox_interval.setMaximum(5000)
    spinbox_interval.setSingleStep(500)
    spinbox_interval.setValue(1000)

    worker = Worker()
    thread = QThread()
    worker.moveToThread(thread)
    thread.started.connect(worker.start)
    thread.start()

    def change_interval():
        value = spinbox_interval.value()
        wrapper = partial(worker.set_interval, value)
        QTimer.singleShot(0, wrapper)

    spinbox_interval.valueChanged.connect(change_interval)

    win.show()
    ret = app.exec_()

    QMetaObject.invokeMethod(worker.timer, "stop")
    thread.quit()
    thread.wait()
    sys.exit(ret)


if __name__ == "__main__":
    main()

如何更改 Qthread 内 Qtimer 的间隔？

How can I change the interval of a Qtimer inside of a Qthread?

python

pyqt

pyqt5

qthread

qtimer