PyQt 崩溃和线程安全

Question

您好 StackExchange 社区，

首先，你们对我帮助很大，非常感谢。第一次提问：

我目前正在编写一个 PyQt GUI 应用程序，我发现它在 Windows 系统上崩溃，而且它在我家的机器上给我一个段错误，而它在工作的机器上工作（都是 linux mint 17）。经过一番研究，我意识到我可能创建了一个线程不安全的 GUI，因为我有几个对象相互调用方法。

From another stackoverflow question: GUI 小部件只能从主线程访问，即调用 QApplication.exec() 的线程。从任何其他线程访问 GUI 小部件——你对 self.parent() 的调用——是未定义的行为，在你的情况下这意味着崩溃。

From Qt docs: 虽然 QObject 是可重入的，但 GUI 类，尤其是 QWidget 及其所有子类，是不可重入的。它们只能在主线程中使用。如前所述，还必须从该线程调用 QCoreApplication::exec()。

所以最后，我认为我应该只使用信号槽系统来这样做。

1. 这是正确的吗？
2. 这只是函数调用需要，还是我可以在运行时以线程安全的方式操作来自其他对象的某些对象的字段？例如，我有一个可以从多个其他对象访问的选项对象，并且我经常从不同的来源更改参数。线程安全还是不安全？

接下来，我在示例代码中重新创建这种线程不安全行为时遇到了问题。 Qt 文档说 QObjects 存在于不同的线程中。这意味着，以下 Qt 应用程序应该是线程不安全的（如果我理解正确的话）。

from PyQt4 import QtGui
import sys

class TestWidget(QtGui.QWidget):
    def __init__(self,string):
        super(TestWidget,self).__init__()
        self.button = QtGui.QPushButton(string,parent=self)
        self.button.clicked.connect(self.buttonClicked)
        
        # just to check, and yes, lives in it's own thread
        print self.thread()
        
    def buttonClicked(self):
        # the seemingly problematic line
        self.parent().parent().statusBar().showMessage(self.button.text())
        pass
    pass

class MainWindow(QtGui.QMainWindow):
    def __init__(self):
        super(MainWindow,self).__init__()
        
        Layout = QtGui.QHBoxLayout()
        for string in ['foo','bar']:
            Layout.addWidget(TestWidget(string))
        
        CentralWidget = QtGui.QWidget(self)
        CentralWidget.setLayout(Layout)
        self.setCentralWidget(CentralWidget)
        self.statusBar()
        self.show()
        pass
    pass

if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)
    M = MainWindow()
    sys.exit(app.exec_())

但它可以在我的机器上运行，也可以在 Windows 机器上正常运行。

1. 为什么？这实际上是线程不安全的并且可能会崩溃，但它不会吗？

感谢您帮我解决这个问题...

Answer 1

这是正确的吗？

是的，您应该只将信号槽系统用于 q 对象之间的交互。 这就是它的本意。

这只是函数调用需要，还是我可以操作一些对象的字段 在运行时以线程安全的方式从其他对象获取数据？

我有一个可以从多个其他对象访问的选项对象...

如果这里的对象是指 Q 对象：

你的options对象应该支持信号槽机制，你可以实现这个 从QObject 派生options。

class Options(QtCore.QObject):
    optionUpdated = QtCore.pyqtSignal(object)

    def __init__(self):

        self.__options = {
            'option_1': None
        }

    def get_option(self, option):
        return self.__options.get(option)

    def set_option(self, option, value):
        self.__options[option] = value
        self.optionUpdated.emit(self)

然后所有使用此选项的小部件/对象都应该有一个连接到此信号的插槽。

一个简单的例子：

    options = Options()
    some_widget = SomeWidget()
    options.optionUpdated.connect(some_widget.options_updated)    // Is like you implement the observer pattern, right?

为什么？这实际上是线程不安全的并且可能会崩溃，但事实并非如此？

thread-unsafe 并不是说​​“一定会崩溃”，而是“这可能会崩溃”或“这很有可能会崩溃”。

来自 pyqt API 文档QObject.thread：

返回对象所在的线程。

勘误

正如 ekumoro 所指出的，我已经重新检查了我之前关于每个对象离开不同线程的立场，并且......我错了！

QObject.thread 将为每个对象返回一个不同的 QThread 实例，但 QThread 实际上并不是一个线程，它只是操作系统提供的那些线程的包装器。

因此，在不同线程中分割多个对象时，代码实际上并没有问题。

为简单起见，我稍微修改了您用于演示的代码：

from PyQt4 import QtGui
import sys

class TestWidget(QtGui.QWidget):
    def __init__(self,string):
        super(TestWidget,self).__init__()
        # just to check, and yes, lives in it's own thread
        print("TestWidget thread: {}".format(self.thread()))

class MainWindow(QtGui.QMainWindow):
    def __init__(self):
        super(MainWindow,self).__init__()
        print("Window thread: {}".format(self.thread()))
        Layout = QtGui.QHBoxLayout()
        for string in ['foo','bar']:
            Layout.addWidget(TestWidget(string))
        self.show()

if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)
    M = MainWindow()
    sys.exit(app.exec_())

是的，打印出来的是：

Window thread: <PyQt4.QtCore.QThread object at 0x00000000025C1048>
TestWidget thread: <PyQt4.QtCore.QThread object at 0x00000000025C4168>
TestWidget thread: <PyQt4.QtCore.QThread object at 0x00000000025C41F8>

演示每个控件都存在于自己的线程中。

现在，您有了信号槽机制来处理这种“线程安全”，任何其他方法都不是线程安全的。

Answer 2

回答您的问题：

1. GUI 小部件只能从主线程（运行 QApplication.exec_())。信号和槽默认是线程安全的，因为 Qt 4

2. 任何导致 direct Qt 图形对象从另一个线程而不是主线程操作的调用 不是 线程安全 => 将崩溃

3. 您的问题代码中没有涉及线程（线程在哪里？？？）， 不同的 QObject 存在于不同的线程中是不正确的。也许你所经历的崩溃无关 带螺纹？

Answer 3

作为一些 cmets 的后续，下面是一个测试脚本，展示了如何检查代码在哪个线程中执行：

from PyQt4 import QtCore, QtGui

class Worker(QtCore.QObject):
    threadInfo = QtCore.pyqtSignal(object, object)

    @QtCore.pyqtSlot()
    def emitInfo(self):
        self.threadInfo.emit(self.objectName(), QtCore.QThread.currentThreadId())

class Window(QtGui.QWidget):
    def __init__(self):
        super(Window, self).__init__()
        self.button = QtGui.QPushButton('Test', self)
        layout = QtGui.QVBoxLayout(self)
        layout.addWidget(self.button)
        self.thread = QtCore.QThread(self)
        self.worker1 = Worker()
        self.worker1.setObjectName('Worker1')
        self.worker1.moveToThread(self.thread)
        self.worker1.threadInfo.connect(self.handleShowThreads)
        self.button.clicked.connect(self.worker1.emitInfo)
        self.worker2 = Worker()
        self.worker2.setObjectName('Worker2')
        self.worker2.threadInfo.connect(self.handleShowThreads)
        self.button.clicked.connect(self.worker2.emitInfo)
        self.thread.start()

    def handleShowThreads(self, name, identifier):
        print('Main: %s' % QtCore.QThread.currentThreadId())
        print('%s: %s\n' % (name, identifier))

    def closeEvent(self, event):
        self.thread.quit()
        self.thread.wait()

if __name__ == '__main__':

    import sys
    app = QtGui.QApplication(sys.argv)
    window = Window()
    window.show()
    sys.exit(app.exec_())