Python/PySide: Wie kann ich Sie zerstören einen beendeten thread-Objekt?

Ich würde gerne implementieren Sie eine Taste zum beenden eines thread mit einem Prozess, es funktioniert aber nicht wie erwartet: ich kann nicht löschen das thread-Objekt. (EDIT: Die Referenz auf das thread-Objekt zu sein scheint gelöscht, aber die Signale sind nicht automatisch getrennt durch löschen des thread-Objekt, auf die ich zugreifen kann es trotzdem über das signal.)

Ich habe ein modul mit einer Klasse thread_worker und eine Funktion für komplexe Verarbeitung, die ausgeführt wird als Prozess:

from PySide.QtCore import *
from PySide.QtGui import *
import multiprocessing as mp
import time

# this function runs as a process
def complex_processing(queue):
    # do something
    ...

class thread_worker(QThread):
    message_signal = Signal(str)
    stop_thread_signal = Signal()

    def __init__(self, prozessID, sleepTime, parent=None):
        super(ThreadProzessWorker, self).__init__(parent)
        self.queue = mp.Queue()
        self.process = mp.Process(target=complex_processing, args=(self.queue,))
        self.timeStamp = int(time.time())

    def run(self):
        self.process.start()
        self.process.join()

    @Slot()
    def stop_process_and_thread(self):
        if self.isRunning():
            self.message_signal.emit("Thread %d is running!" % self.timeStamp)
            if self.process.is_alive():
                self.process.terminate()
                self.process.join()      
            self.stop_thread_signal.emit()   
            #self.terminate() # does it works at this place?       
        else:
            self.message_signal.emit("Thread %d is not running!" % self.timeStamp)

Ich habe zwei buttons in meine Anwendung zu erstellen/ausführen und beenden eines thread-Objekts.

...
...
# Buttons
self.button_start_thread = QPushButton("Start Thread")
self.button_start_thread.clicked.connect(self.start_thread)
self.button_stop_thread = QPushButton("Stop Thread")
...
...
@Slot()
def start_thread(self):
    self.new_thread = thread_worker(self)
    self.button_stop_thread.clicked.connect(self.new_thread.stop_process_and_thread)
    self.new_thread.stop_thread_signal.connect(self.stop_thread)
    self.new_thread.message_signal.connect(self.print_message)
....
....
@Slot()
def stop_thread(self):
    self.new_thread.terminate()
    #self.button_stop_thread.disconnect(self.new_thread)
    del(self.new_thread)

@Slot(str)
def print_message(self, message):
    print(message)
...
...

Wenn ich start und stop der ersten thread - es funktioniert einwandfrei und beenden, aber wenn ich klick auf den "Stop" -Taste erneut, wird die Ausgabe:

Thread 1422117088 is not running!

Ich verstehe es nicht: das Objekt self.new_thread gelöscht wird del(self.new_thread) oder nicht? Wie kann ich auf dieses Objekt, wenn es gelöscht wurde? Wenn ich starten und beenden und wieder einen neuen thread, der Ausgang ist:

Thread 1422117088 is not running!  # not expected, the thread object is deleted!
Thread 1422117211 is running!      # expected

Nun weiß ich es wieder (start und Stopp), die Ausgabe ist:

Thread 1422117088 is not running!   # not expected, the thread object is deleted!
Thread 1422117211 is not running!   # not expected, the thread object is deleted!
Thread 1422117471 is running!       # expected

und so weiter...

Erste Frage:
Ich verstehe nicht, warum die alten threads werden nicht gelöscht? Warum kann ich auf Sie zugreifen? Ich denke, es ist nicht gut: meine Anwendung stürzt ab, irgendwann, wenn es zu viele threads (nicht gelöschte Objekte) in den hintergrund.

Zweite Frage:
Ich dont zu verstehen, warum die Signale nicht getrennt, wenn ich ein Objekt löschen self.new_thread? Ich will nicht zu trennen, die Signale manuell: wenn ich viele Signale kann ich vergessen, zu trennen, einige Signale.

Dritte Frage:
Ich wähle diesen Weg, um zu stoppen, einen thread mit einem Prozess. Gibt es eine andere Möglichkeit das besser zu tun?

UPDATE:

Den thread-Objekt wird zerstört werden:

del(self.new_thread)
print(self.new_thread)
Output: AttributeError: 'MainWindow' object has no attribute 'new_thread'

Aber meine Signale sind nicht getrennt!? Hier beschrieben wird: "Ein signal-slot-Verbindung entfernt wird, wenn einer der beiden beteiligten Objekte sind zerstört." Es funktioniert nicht in meinem code.

Letzter Schuss... Entfernen print(self.new_thread), oder legen Sie Sie in einem try-except-Klausel
Ich habe nicht print(self.new_thread) in meinem code nun, das war nur um zu überprüfen, ob das Objekt gelöscht wird. Wir sehen, dass die Referenz - self.new_thread gelöscht wird, aber nicht das Objekt.

InformationsquelleAutor Igor | 2015-01-24

5

Du hast Recht, dein problem ist, dass Ihr Objekt ist nicht gelöscht. Sie löschen nur der Verweis self.new_thread. Das problem ist in dieser Zeile:
```
self.new_thread = thread_worker(self)
```
Der Grund dafür ist, dass die Eltern self der thread ist lebendig. Solange die Eltern am Leben bleibt, wird das Objekt self.new_thread ist nicht zerstört. Probieren Sie etwas wie dieses:
```
self.threadParent = QObject()
self.new_thread = thread_worker(self.threadParent)
```
Ist und du jetzt auch löschen, die Eltern self.threadParent:
```
self.new_thread.terminate()
del(self.new_thread)
del(self.threadParent)
```
Ihre Signale getrennt werden soll jetzt.

Brauchen Sie nicht die folgende Zeile, weil das Objekt self.new_thread wurde bereits gelöscht, nachdem Sie ein signal auszusenden stop_thread_signal:
```
#self.terminate() # does it works at this place?
```
Ich danke Ihnen sehr! Es funktioniert!

InformationsquelleAutor Tobias
0

Dies geschieht möglicherweise, weil Ihr Prozess nicht alles enthalten, und endet, nachdem es beginnt.Daher der code in
```
def stop_process_and_thread(self):
    if self.isRunning():
        ...
        if self.process.is_alive():
            self.process.terminate()
            self.process.join()      
            self.stop_thread_signal.emit()   
            #self.terminate() # does it works at this place?  
```
nach der wenn selbst.Prozess.is_alive() wird nie erreicht. Als Ergebnis der stop_thread_signal ist nie emittiert also der thread ist weder gekündigt noch gelöscht werden

Ändern Sie Ihre test complex_processing Funktion
```
def complex_processing(queue):
# do something
  while(True):
    print "in process"
    time.sleep(0.2)
```
Nun um den Effekt zu erzielen, die Sie möchten, speichern Sie die threads in einer Liste, so start_thread werden sollte
```
def start_thread(self):
    n = len(self.new_thread)
    self.new_thread.append(thread_worker(self))
    self.new_thread[-1].setTerminationEnabled(True)
    self.new_thread[-1].start()
    if n>0:
        self.button_stop_thread.clicked.disconnect()
    self.button_stop_thread.clicked.connect(self.new_thread[-1].stop_process_and_thread)
    print self.new_thread
    self.new_thread[-1].stop_thread_signal.connect(self.stop_thread)
    self.new_thread[-1].message_signal.connect(self.print_message)
```
Beachten Sie, dass vor der Einrichtung der verbindungen zu den letzten thread von der Liste (Ihre neu hinzugefügte thread), muss man zuerst trennen Sie die Schaltfläche clicked () - signal von allen slots. Das ist, weil, wenn Sie beginnen, mehr als eine threads, die das clicked () - signal angeschlossen werden, um die slots alle. Daher stop_process_and_thread und stop_thread wird aufgerufen, so oft wie die Anzahl der Laufenden threads mit unvorhergesehenen Sequenz.
Durch die Trennung des Signals nur die zuletzt gestartete thread beendet wird und aus der Liste entfernt. Auch sicher sein, dass setTerminationEnabled eingestellt ist

Jedoch nach, dass Sie wieder die Schaltfläche geklickt signal, so müssen Sie auch ändern Sie Ihre stop_thread Methode
```
def stop_thread(self):
    del(self.new_thread[-1])
    if self.new_thread: # if no threads left, then no need ro reconnect signal
         self.button_stop_thread.clicked.connect(self.new_thread[-1].stop_process_and_thread)
    print self.new_thread 
```
Als für die Kündigung dieses kann getan werden, innerhalb der stop_process_and_thread Methode. (Es ist die Zeile, die Sie kommentiert haben aus, Stelle es vor dem aussenden des Signals nur für den Fall)

Das Programm sollte jetzt so Verhalten, wie Sie erwartet

Zur deiner ersten Frage ich bin mir nicht wirklich sicher, wenn threads gelöscht werden, aber sicher, jetzt sind Sie beendet. Irgendwie in deinen bisherigen code, den Sie verlieren den Bezug durch die Zuordnung aller zu einer Variablen, während einige von Ihnen noch aktiv waren. Das beantwortet deine 2. Frage zu

Als für die Dritte, die Beendigung eines Threads auf diese Weise wird nicht empfohlen, in der qt-Dokumentation. Sie sollten die Suche dort für eine bessere und sicherere Wege, und ich bin auch nicht sehr sicher über Ihre Verwendung von multiprocessing, aber ich kann dir nicht mehr sagen, weil ich havent verwendet dieses Modul eine Menge.

Ich glaube, Sie sollten die Strategie ändern, die für die Programmierung dieser. Besser ist die Verwendung von threads innerhalb der Prozesse und nicht-Prozesse im inneren Fäden, wie Sie tun,

Danke für deine Antwort! Ich habe aktualisiert, der code in meiner Frage: (1) complex_processing() etwas tun, es ist ein minimal-Beispiel; (2) self.stop_thread_signal.emit() ist nicht unter if ....
Ich habe setTerminationEnabled(True) in meinem code, aber es funktioniert nicht. Ich kündigen kann der thread auch ohne setTerminationEnabled(True) war es kein problem, ich kann nicht löschen das thread-Objekt - das ist das problem! Ich weiß, dass ich manuell löschen Sie die signal-verbindungen. Ich will nicht, es zu tun manuell, ich möchte zu löschen das thread-Objekt, dann die signal-verbindungen müssen gelöscht werden, auch. Aber es funktioniert nicht.
Haben Sie versucht, das speichern der thread-Objekte in einer Liste, wie ich vermutete? Denn wenn ich das Tat, es scheint, dass Sie gelöscht werden und automatisch getrennt wird (wie es in der Dokumentation erwähnt wird), damit Sie nicht empfangen keine Signale. Die manuelle Trennung ist nicht auf den thread, der gelöscht wurde. Das problem scheint zu sein, meiner Meinung nach, in die Speicherung von verschiedenen thread-Objekte in die gleiche variable.
Um besser zu verstehen, warum sollten Sie verwenden Sie eine Liste, nehmen Sie einen Blick an stackoverflow.com/questions/986006/... vor Allem die 2. Antwort. Wenn Sie löschen die new_thread-variable der Objekte, die Sie zuvor zugewiesen, es könnte immer noch am Leben. new_thread ist einfach nicht mit Bezug auf Sie, aber es gibt Sie noch
Ihr code funktioniert, weil Sie die Verbindung trennen manuell die "stop" - Taste. Wenn ich trennen Sie die Taste manuell mein code funktioniert auch. Ich versuchte es mit einem list und ich haben das gleiche Verhalten wie vorher. Wenn ich die Liste löschen Objekt oder aus der Liste löschen, die Signale sind nicht getrennt. Ich glaube, ich verstehe das Zeug über Daten-Modell: "- Objekte nicht explizit gelöscht werden; jedoch, wenn Sie nicht erreichbar sein können Sie werden, Müll gesammelt." (docs.python.org/3.4/reference/datamodel.html).

InformationsquelleAutor finmor

Ich haben sich mit diesem problem vor und lösen es so:

import time
from threading import Thread

class myClass(object):
    def __init__(self):
        self._is_exiting = False

        class dummpyClass(object):
            pass
        newSelf = dummpyClass()
        newSelf.__dict__ = self.__dict__

        self._worker_thread = Thread(target=self._worker, args=(newSelf,), daemon=True)

    @classmethod
    def _worker(cls, self):
        i = 0
        while not self._is_exiting:
            print('Loop #{}'.format(i))
            i += 1
            time.sleep(3)
    def __del__(self):
        self._is_exiting = True
        self._worker_thread.join()

Den Einsatz von dummpyClass ermöglicht dem Arbeiter, der den Zugriff auf alle Attribute unserer main-Klasse, aber es nicht wirklich zeigen. Also, wenn wir löschen unsere main-Klasse, ist es möglich, um es vollständig de-referenziert.

test = myClass()
test._worker_thread.start()

Beachten Sie, dass unsere Arbeiter zu drucken startet die Ausgabe.

del test

Worker-thread wurde beendet.

Einer komplexeren Art und Weise, dieses problem zu lösen, die Ihnen erlauben würde, den Zugang zu Methoden myClass wäre zunächst definieren Sie eine Basis-Klasse (nennen wir es myClass_base) , speichert alle Daten und benötigten Methoden, aber kein threading unterstützen. Dann fügen Sie auf der threading-Unterstützung in einer neuen Klasse.

import time
from threading import Thread
class myClass_base(object):
    def __init__(self, specialValue):
        self.value = specialValue
    def myFun(self, x):
        return self.value + x

class myClass(myClass_base):
    def __init__(self, *args, **kwargs):

        super(myClass, self).__init__(*args, **kwargs)

        newSelf = myClass_base.__new__(myClass_base)
        newSelf.__dict__ = self.__dict__

        self._is_exiting = False

        self.work_to_do = []

        self._worker_thread = Thread(target=self._worker, args=(newSelf,), daemon=True)

    @classmethod
    def _worker(cls, self):
        i = 0
        while not self._is_exiting:
            if len(self.work_to_do) > 0:
                x = self.work_to_do.pop()
                print('Processing {}.  Result = {}'.format(x, self.myFun(x)))
            else:
                print('Loop #{}, no work to do!'.format(i))
            i += 1
            time.sleep(2)

    def __del__(self):
        self._is_exiting = True
        self._worker_thread.join()

Starten diese Klasse ausführen:

test = myClass(3)
test.work_to_do+=[1,2,3,4]
test._worker_thread.start()

Und beachten Sie, dass die Ergebnisse ausdrucken. Löschen funktioniert genauso wie vorher. ausführen

del test

und der thread ordnungsgemäß beendet wird.

InformationsquelleAutor Thomas Wentworth

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.