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