Python/PySide: 如何销毁已终止的线程对象？

Question

我想实现一个按钮来停止带有进程的线程，它可以工作但不像预期的那样：我无法删除线程对象。（编辑： 线程对象的引用似乎被删除了，但是信号并没有通过删除线程对象自动断开，我仍然可以通过信号访问它。）

我有一个带有 class thread_worker 的模块和一个用于复杂处理的函数运行 as process:

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)

我的应用程序中有两个按钮 create/run 和终止线程对象。

...
...
# 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)
...
...

如果我启动和停止第一个线程 - 它工作正常并终止，但如果我再次点击 'Stop'- 按钮，输出为：

Thread 1422117088 is not running!

不明白：对象self.new_thread是不是被del(self.new_thread)删除了？如果它被删除，我如何访问该对象？如果我再次启动并停止一个新线程，输出为：

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

现在我再做一次（开始和停止），输出是：

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

等等...

第一题： 我不明白为什么不删除旧线程？为什么我可以访问它们？我认为这不好：如果后台有太多线程（未删除的对象），我的应用程序有时会崩溃。

第二个问题： 我不明白为什么如果我删除对象 self.new_thread 信号没有断开？我不想手动断开信号：如果我有很多信号，我可能会忘记断开某些信号。

第三题： 我选择这种方式来停止一个进程的线程。还有其他更好的方法吗？

更新：

线程对象似乎已被销毁：

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

但是我的信号没有断开！？ Here 描述为："A signal-slot connection is removed when either of the objects involved are destroyed." 它在我的代码中不起作用。

Answer 1

发生这种情况可能是因为您的进程不包含任何内容并在它之后完成 starts.Therefore

中的代码

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?

after if self.process.is_alive() 永远不会到达。结果 stop_thread_signal 永远不会发出，因此线程既不会终止也不会删除

将测试 complex_processing 函数更改为

def complex_processing(queue):
# do something
  while(True):
    print "in process"
    time.sleep(0.2)

现在要实现您想要的效果，您应该将线程存储在列表中，这样 start_thread 应该变成

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)

请注意，在设置与列表的最后一个线程（您新添加的线程）的连接之前，您必须首先断开所有插槽的按钮 clicked() 信号。这是因为如果您启动多个线程，clicked() 信号将连接到所有线程的插槽。因此 stop_process_and_thread 和 stop_thread 将被调用的次数与运行线程的数量一样多顺序。通过断开信号，只有最后启动的线程被终止并从列表中删除。还要确保设置了 setTerminationEnabled

但是之后你必须重新连接按钮点击信号，所以你也必须将你的 stop_thread 方法更改为

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

至于终止，这可以在 stop_process_and_thread 方法中完成。（就是你注释掉的那一行，放在发出信号前以防万一）

现在您的程序应该按预期运行

对于你的第一个问题，我不太确定线程是否被删除，但可以肯定它们现在已经终止。不知何故，在您之前的代码中，您通过将所有变量分配给一个变量而其中一些变量仍然处于活动状态而丢失了引用。这也回答了你的第二个问题

至于第三种，qt 文档中不推荐以这种方式终止线程。你应该在那里搜索更好更安全的方法，我也不太确定你对多处理的使用，但我不能告诉你更多，因为我没有经常使用这个模块。

我认为您应该更改对此进行编程的策略。最好在进程内使用线程，而不是像您那样在线程内使用进程

Answer 2

你是对的，你的问题是你的对象没有被删除。您仅删除引用 self.new_thread。问题出在这一行：

self.new_thread = thread_worker(self)

原因是线程的父self还活着。只要 parent 还活着，对象 self.new_thread 就不会被销毁。尝试这样的事情：

self.threadParent = QObject()
self.new_thread = thread_worker(self.threadParent)

现在您还删除了父级 self.threadParent:

self.new_thread.terminate()
del(self.new_thread)
del(self.threadParent)

你的信号现在应该断开了。

你不需要下面这行，因为对象self.new_thread在你发出信号stop_thread_signal:

后已经被删除了

#self.terminate() # does it works at this place?

Answer 3

我以前处理过这个问题，是这样解决的：

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()

dummpyClass 的使用允许 worker 访问我们的 main class 的所有属性，但它实际上并不指向它。因此，当我们删除 main class 时，它可能会被完全取消引用。

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

请注意，我们的工作人员开始打印输出。

del test

工作线程已停止。

解决此问题的一种更复杂的方法是首先定义一个存储所有数据和所需方法的基 class（称之为 myClass_base），这样您就可以访问方法 myClass，但没有线程支持。然后在新的 class.

中添加线程支持

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()

要开始这个 class 执行：

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

请注意结果开始打印出来。删除工作与以前相同。执行

del test

并且线程正常退出。

Python/PySide: 如何销毁已终止的线程对象？

Python/PySide: How can i destroy a terminated thread object?

python

multithreading

pyqt

multiprocessing

pyside