python - 在调用 deleteLater() 后直接删除对 Qt 对象的 Python 引用是否安全？

Question

请考虑下面的最小示例，它实现了一个自定义 QNetworkAccessManager，它维护一个未完成的 QNetworkReply 实例列表。

当回复完成时，它会从unfinished_replies列表中移除。

如 Is deleteLater() necessary in PyQt/PySide? 中所述, QNetworkReply.deleteLater() 用于在 finished 槽内安排 Qt 对象删除。

但是，我不确定删除对回复对象的 Python 引用的最佳方法是什么。我可以想到两个(互斥的)选项来删除 Python 引用，如下例所示:

1. 调用deleteLater()

   后直接删除

2. 在发出 QNetworkReply.destroyed 信号时移除 ( docs )

这两个选项似乎都工作得很好。我更喜欢选项 1，但我不确定在极少数情况下这是否会导致意外。哪个最好？或者有其他选择吗？

import sys
from PyQt5 import QtNetwork, QtWidgets, QtCore


class CustomNetworkAccessManager(QtNetwork.QNetworkAccessManager):
    def __init__(self):
        super(CustomNetworkAccessManager, self).__init__()
        self.unfinished_replies = []
        self.finished.connect(self.slot)

    def get(self, *args, **kwargs):
        reply = super(CustomNetworkAccessManager, self).get(*args, **kwargs)
        reply.index = i  # just for printing
        self.unfinished_replies.append(reply)

    def remove_from_list(self, reply):
        self.unfinished_replies.remove(reply)
        print('{} unfinished replies left'.format(len(self.unfinished_replies)))
        if not self.unfinished_replies:
            QtCore.QCoreApplication.quit()

    def slot(self, reply):
        print('reply {} finished'.format(reply.index))
        # handle the Qt side:
        reply.deleteLater()  
        # handle the Python side:
        # either
        # OPTION 1 - remove now
        self.remove_from_list(reply)
        # or 
        # OPTION 2 - remove when destroyed
        # reply.destroyed.connect(lambda: self.remove_from_list(reply))


if __name__ == '__main__':
    # Initialize
    app = QtWidgets.QApplication(sys.argv)
    manager = CustomNetworkAccessManager()

    # Schedule requests
    url = 'http://httpbin.org/get'
    for i in range(6):
        manager.get(QtNetwork.QNetworkRequest(QtCore.QUrl(url)))

    # Start event loop
    app.exec_()

附注对不起 Python 2 代码

Answer 1

两者是等价的，它们只是在删除它们的那一刻有所不同。但要了解更多细节，您必须了解 PyQt5/PySide2 绑定(bind)的工作原理。这些库围绕 C++ 对象创建了一个包装器，类似于:

class FooWrapper:
    def __new__(self, cls, *args, **kwargs):
         # ...
         instance = ...
         instance._cpp_object = create_cpp_object()
         # ...
         return instance

    def foo_method(self, *args, **kwargs):
        return execute_foo_method(self._cpp_object, *args, **kwargs)

    def __del__(self):
        destroyed_cpp_object(self._cpp_object)

因此，当调用 deleteLater 时，仅删除 cpp_object 而不是包装器，您可以验证是否使用:

reply.destroyed.connect(self.remove_from_list)

Traceback (most recent call last):
  File "main.py", line 32, in <lambda>
    reply.destroyed.connect(self.remove_from_list)
  File "main.py", line 17, in remove_from_list
    self.unfinished_replies.remove(reply)
ValueError: list.remove(x): x not in list

由于 destroyed 传递的参数是一个无效的包装器导致上述错误。对于这种情况，一个解决方案是检查 cpp_object 是否已使用 sip.isdeleted() 删除:

from PyQt5 import QtNetwork, QtWidgets, QtCore
import sip

# ...
class CustomNetworkAccessManager(QtNetwork.QNetworkAccessManager):
    # ...

    def remove_from_list(self):
        self.unfinished_replies = [
            reply for reply in self.unfinished_replies if not sip.isdeleted(reply)
        ]
        print("{} unfinished replies left".format(len(self.unfinished_replies)))
        if not self.unfinished_replies:
            QtCore.QCoreApplication.quit()

    def slot(self, reply):
        print("reply {} finished".format(reply.index))
        # handle the Qt side:
        reply.deleteLater()
        # handle the Python side:
        reply.destroyed.connect(self.remove_from_list)

回到对您的方法的研究，这些可以绘制如下:

(FIRST METHOD)
------------┬------------------┬---------------------┬-----------------------
            |                  |                     |
 call_deleteLater remove_reply_from_list          destroyed

(SECOND METHOD)
------------┬-----------------------------------------┬-----------------┬------
            |                                         |                 |
 call_deleteLater                               destroyed remove_reply_from_list

而且由于您使用的是原始包装器，所以应该没有任何问题。

结论:两者等效且安全。