简单、非阻塞的后台调用

Question

我正在编写一个通过串行连接与硬件通信的 PySide 应用程序。

我有一个按钮来启动设备命令和一个标签来向用户显示结果。 现在一些设备需要很长时间（几秒钟）来响应请求，这会冻结 GUI。我正在寻找一种简单的机制来在后台线程或类似线程中运行调用。

我创建了一个我想要完成的简短示例：

import sys
import time
from PySide import QtCore, QtGui


class Device(QtCore.QObject):

    def request(self, cmd):
        time.sleep(3)
        return 'Result for {}'.format(cmd)


class Dialog(QtGui.QDialog):

    def __init__(self, device, parent=None):
        super().__init__(parent)
        self.device = device

        self.layout = QtGui.QHBoxLayout()
        self.label = QtGui.QLabel('--')
        self.button = QtGui.QPushButton('Go')
        self.layout.addWidget(self.label)
        self.layout.addWidget(self.button)
        self.setLayout(self.layout)

        self.button.clicked.connect(self.go)

    def go(self):
        self.button.setEnabled(False)

        # the next line should be called in the
        # background and not freeze the gui
        result = self.device.request('command')

        self.label.setText(result)
        self.button.setEnabled(True)


if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)
    dev = Device()
    win = Dialog(device=dev)
    win.show()
    win.raise_()
    app.exec_()

我想要的是某种功能，例如：

result = nonblocking(self.device.request, 'command')

应该像我直接调用函数一样引发异常。

有什么想法或建议吗？

Answer 1

线程是最好的方法。 Python 线程也很容易使用。 Qt 线程的工作方式与 python 线程不同。 http://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/

我只使用 python 线程。此外，如果您使用的是串行端口连接，您可能希望将数据拆分到线程安全的队列中。

import time
import threading
import queue
import serial

def read_serial(serial, storage):
    while True:
        value = serial.readline()
        storage.put(value) # or just process the data

ser = serial.SerailPort("Com1", 9600)
stor = queue.Queue()
th = threading.Thread(target=read_serial, args=(ser, stor))
th.start()
for _ in range(10):
    time.sleep(1)
th.join(0)
ser.close()
# Read queue

您可以做的另一件事是对串行端口和 QObject 使用多重继承。这允许您使用 Qt 信号。下面是一个非常粗略的例子。

class SerialThread(object):
    def __init__(self, port=None, baud=9600):
        super().__init__()

        self.state = threading.Condition() # Notify threading changes safely
        self.alive = threading.Event() # helps with locking

        self.data = queue.Queue()
        self.serial = serial.Serial()
        self.thread = threading.Thread(target=self._run)

        if port is not None:
            self.connect(port, baud)
    # end Constructor

    def connect(self, port, baud):
        self.serial.setPort(port)
        self.serial.setBaudrate(baud)
        self.serial.open()

        with self.state:
            self.alive.set()
        self.thread.start()
    # end connect

    def _run(self):
        while True:
            with self.state:
                if not self.alive.is_set():
                    return

            self.read()
    # end _run

    def read(self):
        serstring = bytes("", "ascii")
        try:
            serstring = self.serial.readline()
        except:
            pass
        else:
            self.process_read(serstring)
        return serstring # if called directly
    # end read

    def process_read(self, serstring):
        if self.queue.full():
            self.queue.get(0) # remove the first item to free up space
        self.queue.put(serstring)
    # end process_read

    def disconnect(self):
        with self.state:
            self.alive.clear()
            self.state.notify()
        self.thread.join(0) # Close the thread
        self.serial.close() # Close the serial port
    # end disconnect
# end class SerialThread

class SerialPort(SerialThread, QtCore.QObject):
    data_updated = QtCore.Signal()

    def process_read(self, serstring):
        super().process_read(serstring)
        self.data_updated.emit()
    # end process_read
# end class SerialPort


if __name__ == "__main__":
    ser = SerialPort()
    ser.connect("COM1", 9600)
    # Do something / wait / handle data
    ser.disconnect()
    ser.queue.get() # Handle data

与往常一样，请确保在退出时正确关闭并断开所有连接。另请注意，线程只能运行一次，因此您可能需要查看可暂停线程示例How to start and stop thread?。 您也可以只通过 Qt Signal 发出数据，而不是使用队列来存储数据。

Answer 2

我想要的是某种功能，例如：

    result = nonblocking(self.device.request, 'command')

您在这里所要求的实际上是不可能的。您不能让非阻塞调用立即返回结果！根据定义，这将是一个阻塞调用。

非阻塞调用看起来像：

self.thread = inthread(self.device.request, 'command', callback)

self.device.request 在串行请求完成时运行callback 函数/方法。但是，从线程内天真地调用callback() 将使回调在线程中运行，如果您要从callback 方法调用Qt GUI，这是非常非常糟糕的（Qt GUI 方法不是线程安全的） .因此，您需要一种在 MainThread 中运行回调的方法。

我对此类函数也有类似的需求，并且（与一位同事）创建了一个库（称为qtutils），其中包含一些不错的包装函数（包括inthread 的实现）。它通过使用QApplication.postEvent() 将事件发布到主线程来工作。该事件包含对要运行的函数的引用，并且事件处理程序（位于主线程中）执行该函数。所以你的 request 方法看起来像：

def request(self, cmd, callback):
    time.sleep(3)
    inmain(callback, 'Result for {}'.format(cmd))

inmain() 将事件发布到主线程并运行callback(data)。

可以在here 找到此库的文档，或者，您也可以根据上面的大纲来扮演自己的角色。如果你选择使用我的库，可以通过 pip 或 easy_install 安装。

注意：此方法的一个警告是 QApplication.postEvent() leaks memory in PySide。这就是我现在使用 PyQt 的原因！