Comment garder une trace de la progression du thread en Python sans geler L'interface graphique PyQt?

Questions:

1. Quelle est la meilleure pratique pour garder la trace d'une bande de roulement progresser sans verrouiller L'interface graphique ("Pas De Réponse")?
2. en général, quelles sont les meilleures pratiques filetage tel qu'il s'applique à GUI le développement?

Question Contexte:

• j'ai une interface graphique PyQt Pour Windows.
• il est utilisé pour traiter des ensembles de HTML document.
• il faut n'importe où de trois secondes à trois heures pour traiter un ensemble de document.
• je veux être capable de traiter plusieurs jeux en même temps.
• Je ne veux pas que l'interface graphique soit verrouillée.
• je regarde le module de filetage pour atteindre cet objectif.
• je suis relativement nouveau au filetage.
• le GUI a un la barre de progression.
• je veux qu'il affiche la progression de le fil sélectionné.
• affiche les résultats de la sélection thread si c'est fini.
• J'utilise Python 2.5.

Mon Idée: Ont les fils émettent un QtSignal lorsque la progression est mise à jour qui déclenche une fonction qui met à jour la barre de progression. Signal également lorsque le traitement terminé de sorte que les résultats peuvent être affichés.

#NOTE: this is example code for my idea, you do not have
#      to read this to answer the question(s).

import threading
from PyQt4 import QtCore, QtGui
import re
import copy

class ProcessingThread(threading.Thread, QtCore.QObject):

    __pyqtSignals__ = ( "progressUpdated(str)",
                        "resultsReady(str)")

    def __init__(self, docs):
        self.docs = docs
        self.progress = 0   #int between 0 and 100
        self.results = []
        threading.Thread.__init__(self)

    def getResults(self):
        return copy.deepcopy(self.results)

    def run(self):
        num_docs = len(self.docs) - 1
        for i, doc in enumerate(self.docs):
            processed_doc = self.processDoc(doc)
            self.results.append(processed_doc)
            new_progress = int((float(i)/num_docs)*100)

            #emit signal only if progress has changed
            if self.progress != new_progress:
                self.emit(QtCore.SIGNAL("progressUpdated(str)"), self.getName())
            self.progress = new_progress
            if self.progress == 100:
                self.emit(QtCore.SIGNAL("resultsReady(str)"), self.getName())

    def processDoc(self, doc):
        ''' this is tivial for shortness sake '''
        return re.findall('<a [^>]*>.*?</a>', doc)


class GuiApp(QtGui.QMainWindow):

    def __init__(self):
        self.processing_threads = {}  #{'thread_name': Thread(processing_thread)}
        self.progress_object = {}     #{'thread_name': int(thread_progress)}
        self.results_object = {}      #{'thread_name': []}
        self.selected_thread = ''     #'thread_name'

    def processDocs(self, docs):
        #create new thread
        p_thread = ProcessingThread(docs)
        thread_name = "example_thread_name"
        p_thread.setName(thread_name)
        p_thread.start()

        #add thread to dict of threads
        self.processing_threads[thread_name] = p_thread

        #init progress_object for this thread
        self.progress_object[thread_name] = p_thread.progress  

        #connect thread signals to GuiApp functions
        QtCore.QObject.connect(p_thread, QtCore.SIGNAL('progressUpdated(str)'), self.updateProgressObject(thread_name))
        QtCore.QObject.connect(p_thread, QtCore.SIGNAL('resultsReady(str)'), self.updateResultsObject(thread_name))

    def updateProgressObject(self, thread_name):
        #update progress_object for all threads
        self.progress_object[thread_name] = self.processing_threads[thread_name].progress

        #update progress bar for selected thread
        if self.selected_thread == thread_name:
            self.setProgressBar(self.progress_object[self.selected_thread])

    def updateResultsObject(self, thread_name):
        #update results_object for thread with results
        self.results_object[thread_name] = self.processing_threads[thread_name].getResults()

        #update results widget for selected thread
        try:
            self.setResultsWidget(self.results_object[thread_name])
        except KeyError:
            self.setResultsWidget(None)

tout commentaire sur cette approche (par exemple inconvénients, pièges, louanges, etc.) sera appréciée.

résolution:

j'ai fini par utiliser la classe QThread et les signaux associés et les fentes pour communiquer entre les fils. Ceci est principalement dû au fait que mon programme utilise déjà Qt/PyQt4 pour les objets/widgets GUI. Cette solution nécessitait également moins de modifications à mon code existant pour être mise en œuvre.

voici un lien vers un article QT applicable qui explique comment Qt gère les threads et les signaux, http://www.linuxjournal.com/article/9602 . Extrait ci-dessous:

heureusement, QT permet signaux et emplacements à connecter à travers les fils-aussi longtemps que les fils sont en train d'exécuter leurs propres boucles d'événements. C'est beaucoup plus propre méthode de la communication par rapport à l'envoi et recevoir des événements, parce qu'il éviter toute la comptabilité et intermédiaires Les classes dérivées de QEvent qui deviennent nécessaire dans tout non trivial application. La communication entre fils devient maintenant une question de les signaux de connexion d'un fil à les fentes dans une autre, et le mutexing et les questions de sécurité du fil de l'échange les données entre les threads sont gérées par Qt.

Pourquoi est-il nécessaire de gérer un événement boucle à l'intérieur de chaque fil auquel vous souhaitez connecter des signaux? Raison a à voir avec l'inter-thread mécanisme de communication utilisé par Qt lors de la connexion de signaux à partir d'un filez dans la fente d'un autre fil. Lorsqu'une connexion est établie, il est désigné comme une file d'attente de connexion. Lorsque des signaux sont émis par l'intermédiaire d'un connexion en file d'attente, la fente est invoquée la prochaine fois que l'objet de destination la boucle d'événement est exécutée. Si la fente cela avait été invoquée directement par un signal d'un autre fil, Cette fente exécuté dans le même contexte comme le thread appelant. Normalement, c'est pas ce que vous voulez (et surtout pas ce que vous voulez si vous utilisez un connexion de base de données, comme la base de données la connexion ne peut être utilisée que par le fil qui l'a créé). La file d'attente la connexion expédie correctement signal à l'objet thread et invoque sa fente dans son propre contexte par piggy-backing sur le système d'événements. C'est précisément ce que nous voulons pour communication inter-thread dans laquelle certains fils sont manipulés connexions de base de données. L'Intervalle Qt le mécanisme de signal/fente est à la racine la mise en œuvre de l'inter-thread schéma de passage d'un événement décrit ci-dessus, mais avec une beaucoup plus propre et plus facile à utiliser l'interface.

NOTE: eliben a aussi une bonne réponse, et si je n'utilisais pas PyQt4, qui gère la sécurité du fil et le mutexing, sa solution aurait été mon choix.