Signale von mehreren Worker-Threads an den GUI-Thread senden

Question

Ich habe eine GUI mit 24 Textfeldern, und ich möchte für jeden einen Thread erstellen und das Textfeld mit Informationen aus dem jeweiligen Thread aktualisieren.

Wo ich feststecke, empfängt das Signal, um die GUI von allen Threads zu aktualisieren.

Code:

#!/usr/bin/python 
# Standard Lib 
import logging 
import os 
import sys 
import time 
# Third Party 
from PyQt4 import QtGui 
from PyQt4 import QtCore 
# Local Kung Fu 
from bin import serial_lib, logger, get_args, utils 
from bin.assets.test_suite_gui_form import Ui_MainWindow 

class Tester(QtCore.QThread): 
    def __init__(self): 
     QtCore.QThread.__init__(self) 
     self.color = "RED" 
     self.status = "Disconnected" 

    def __del__(self): 
     self.wait() 

    def run(self): 
     self.emit(QtCore.SIGNAL('update(QString)'), "color={} status={}".format(self.color, self.status)) 
     return 

class TestSuiteGUI(QtGui.QMainWindow): 

    def __init__(self, parent=None): 
     QtGui.QWidget.__init__(self, parent) 
     # Init class from template 
     self.ui = Ui_MainWindow() 
     # Get list of com ports to populate app on init 
     self.com_ports_list = serial_lib.get_com_ports() 
     # Build UI 
     self.ui.setupUi(self) 
     # Update Labels with COM Ports, where possible, filtered by drivers 
     self.update_comm_fields(self.com_ports_list) 
     for num, com_port_chunk in zip(range(1,25), self.com_ports_list): 
      tester_thread = Tester(com_port_chunk, num) 
      tester_thread.start() 

    def update_comm_fields(self, com_ports_list): 
     for num, port, in zip(range(1, 25), range(0, 24)): 
      label = getattr(self.ui, 'com_{}'.format(num)) 
      label.setText("COM Port: {}".format(com_ports_list[port]["COM"])) 

if __name__ == "__main__": 
    # Grab args from CLI if necessary 
    args = get_args.get_args() 
    # Log file 
    log_file = os.path.join(utils.app_path, "log", "log.txt") 
    # Get Logger 
    logger.get_logger(log_file, verbose=True) 
    # Init App and display 
    app = QtGui.QApplication(sys.argv) 
    test_suite = TestSuiteGUI() 
    test_suite.show() 
    # Close app only when window is closed. 
    sys.exit(app.exec_()) 

Ist das der richtige Ansatz? Ich versuchte mit QRunnable und einem Thread-Pool, aber irgendwo gelesen, dass Signale nicht damit arbeiten. Sollte ich einfach Pythons Multithreading-Bibliothek als letzten Ausweg oder vielleicht als ereignisbasiertes System ausprobieren, da alles, was ich brauche, eine Zeichenfolge und Boolesche Werte ist?

Answer 1

Sie sollten definieren und das Signal wie folgt emittieren:

class Tester(QtCore.QThread): 
    updateText = QtCore.pyqtSignal(str) 
    ...  
    def run(self): 
     self.updateText.emit("color={} status={}".format(self.color, self.status)) 

Dann können Sie auf die Signale wie folgt verbinden:

class TestSuiteGUI(QtGui.QMainWindow): 
    def __init__(self, parent=None): 
     ... 
     # keep a reference to the threads 
     self._threads = [] 
     for num, com_port_chunk in zip(range(1,25), self.com_ports_list): 
      tester_thread = Tester(com_port_chunk, num) 
      # get a reference to the associated textbox somehow... 
      textbox = get_the_textbox() 
      tester_thread.updateText.connect(textbox.setText) 
      tester_thread.start() 
      self._threads.append(tester_thread) 

Offensichtlich ist dies ein wenig seltsam, weil es unmöglich ist, zu teste dein Beispiel.