• 8.23 循环引用数据结构的内存管理
    • 问题
    • 解决方案
    • 讨论

    8.23 循环引用数据结构的内存管理

    问题

    你的程序创建了很多循环引用数据结构(比如树、图、观察者模式等),你碰到了内存管理难题。

    解决方案

    一个简单的循环引用数据结构例子就是一个树形结构,双亲节点有指针指向孩子节点,孩子节点又返回来指向双亲节点。这种情况下,可以考虑使用 weakref 库中的弱引用。例如:

    1. import weakref
    2.  
    3. class Node:
    4. def __init__(self, value):
    5. self.value = value
    6. self._parent = None
    7. self.children = []
    8.  
    9. def __repr__(self):
    10. return 'Node({!r:})'.format(self.value)
    11.  
    12. # property that manages the parent as a weak-reference
    13. @property
    14. def parent(self):
    15. return None if self._parent is None else self._parent()
    16.  
    17. @parent.setter
    18. def parent(self, node):
    19. self._parent = weakref.ref(node)
    20.  
    21. def add_child(self, child):
    22. self.children.append(child)
    23. child.parent = self

    这种是想方式允许parent静默终止。例如:

    1. >>> root = Node('parent')
    2. >>> c1 = Node('child')
    3. >>> root.add_child(c1)
    4. >>> print(c1.parent)
    5. Node('parent')
    6. >>> del root
    7. >>> print(c1.parent)
    8. None
    9. >>>

    讨论

    循环引用的数据结构在Python中是一个很棘手的问题,因为正常的垃圾回收机制不能适用于这种情形。例如考虑如下代码:

    1. # Class just to illustrate when deletion occurs
    2. class Data:
    3. def __del__(self):
    4. print('Data.__del__')
    5.  
    6. # Node class involving a cycle
    7. class Node:
    8. def __init__(self):
    9. self.data = Data()
    10. self.parent = None
    11. self.children = []
    12.  
    13. def add_child(self, child):
    14. self.children.append(child)
    15. child.parent = self

    下面我们使用这个代码来做一些垃圾回收试验:

    1. >>> a = Data()
    2. >>> del a # Immediately deleted
    3. Data.__del__
    4. >>> a = Node()
    5. >>> del a # Immediately deleted
    6. Data.__del__
    7. >>> a = Node()
    8. >>> a.add_child(Node())
    9. >>> del a # Not deleted (no message)
    10. >>>

    可以看到,最后一个的删除时打印语句没有出现。原因是Python的垃圾回收机制是基于简单的引用计数。当一个对象的引用数变成0的时候才会立即删除掉。而对于循环引用这个条件永远不会成立。因此,在上面例子中最后部分,父节点和孩子节点互相拥有对方的引用,导致每个对象的引用计数都不可能变成0。

    Python有另外的垃圾回收器来专门针对循环引用的,但是你永远不知道它什么时候会触发。另外你还可以手动的触发它,但是代码看上去很挫:

    1. >>> import gc
    2. >>> gc.collect() # Force collection
    3. Data.__del__
    4. Data.__del__
    5. >>>

    如果循环引用的对象自己还定义了自己的 del() 方法,那么会让情况变得更糟糕。假设你像下面这样给Node定义自己的 del() 方法:

    1. # Node class involving a cycle
    2. class Node:
    3. def __init__(self):
    4. self.data = Data()
    5. self.parent = None
    6. self.children = []
    7.  
    8. def add_child(self, child):
    9. self.children.append(child)
    10. child.parent = self
    11.  
    12. # NEVER DEFINE LIKE THIS.
    13. # Only here to illustrate pathological behavior
    14. def __del__(self):
    15. del self.data
    16. del.parent
    17. del.children

    这种情况下,垃圾回收永远都不会去回收这个对象的,还会导致内存泄露。如果你试着去运行它会发现,Data.del 消息永远不会出现了,甚至在你强制内存回收时:

    1. >>> a = Node()
    2. >>> a.add_child(Node()
    3. >>> del a # No message (not collected)
    4. >>> import gc
    5. >>> gc.collect() # No message (not collected)
    6. >>>

    弱引用消除了引用循环的这个问题,本质来讲,弱引用就是一个对象指针,它不会增加它的引用计数。你可以通过 weakref 来创建弱引用。例如:

    1. >>> import weakref
    2. >>> a = Node()
    3. >>> a_ref = weakref.ref(a)
    4. >>> a_ref
    5. <weakref at 0x100581f70; to 'Node' at 0x1005c5410>
    6. >>>

    为了访问弱引用所引用的对象,你可以像函数一样去调用它即可。如果那个对象还存在就会返回它,否则就返回一个None。由于原始对象的引用计数没有增加,那么就可以去删除它了。例如;

    1. >>> print(a_ref())
    2. <__main__.Node object at 0x1005c5410>
    3. >>> del a
    4. Data.__del__
    5. >>> print(a_ref())
    6. None
    7. >>>

    通过这里演示的弱引用技术,你会发现不再有循环引用问题了,一旦某个节点不被使用了,垃圾回收器立即回收它。你还能参考8.25小节关于弱引用的另外一个例子。

    原文:

    http://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p23_managing_memory_in_cyclic_data_structures.html