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

Question

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

当回复为finished 时，将其从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 绑定的工作原理。这些库围绕 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传递的参数是一个无效的包装器，所以会出现上述错误。对于这种情况，一种解决方案是使用 sip.isdeleted() 检查 cpp_object 是否已被删除：

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

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

结论：两者等效且安全。