Python数据结构与算法（11）---对象的非永久引用weakref

Posted 2021-06-29 一天一篇Python库

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python数据结构与算法（11）---对象的非永久引用weakref相关的知识，希望对你有一定的参考价值。

对象的非永久引用weakref

weakref库支持对象的弱引用。正常的引用会增加对象的引用数，并避免它被垃圾回收。但结果并不总是期望的那样。

比如，有时候可能会出现一个循环引用，或者有时候需要内存时，可能要删除对象的缓存。而弱引用是一个不能避免对象被自动清理的对象句柄。

引用

下面，我们来看一个简单的例子，示例如下：

import weakref

class MyObject:
    def __del__(self):
        print('删除{}'.format(self))

obj = MyObject()
r = weakref.ref(obj)
print('obj:', obj)
print('ref:', r)
print('r():', r())

print("删除对象引用")
del obj
print('r():', r())

运行之后，控制台输出如下：

这里对象的弱引用需要通过ref类来管理，要获取原对象，可以调用引用对象。这里，由于obj在第二次调用引用之前已经被删除，所以ref返回None。

引用回调

ref的构造函数还有一个可选参数，删除所所应用的对象时，会调用这个函数，也就是java里常说的回调函数。示例如下：

import weakref

class MyObject:
    def __del__(self):
        print('删除{}'.format(self))

def callBack(reference):
    print('callback{}'.format(reference))

obj = MyObject()
r = weakref.ref(obj, callBack)
print('obj:', obj)
print('ref:', r)
print('r():', r())

print("删除对象引用")
del obj
print('r():', r())

相对于前面的代码，除了多出一个方法，以及一个参数之外，其他的代码一模一样。运行之后，效果如下：
引用回调

当引用已经死亡，不再引用原对象时，就会触发这个回调函数。因为回调函数接收的参数是引用对象，所以这个特性的一种用法是从缓存中删除弱引用对象。

最终化对象

清理弱引用时要对资源完成更健壮的管理，可以使用finalize将回调与对象关联。finalize实例会一直保留，直到所关联的对象被删除，即使应用并没有保留最终化对象的引用。

示例如下：

import weakref

class MyObject:
    def __del__(self):
        print('删除{}'.format(self))

def on_finalize(*args):
    print('on_finalize-----{}'.format(args))

obj=MyObject()
weakref.finalize(obj,on_finalize,'额外参数')

del obj

运行之后，效果如下：
最终化对象1

finalize参数包括要跟踪对象，对象被垃圾回收时要调用的回调函数on_finalize以及传入这个回调函数的所有位置或命令参数。

不过，finalize还有一个属性atexit，它用来控制程序退出时是否调用这个回调（如果还没有调用的话），示例如下：

f = weakref.finalize(obj, on_finalize, '额外参数')
f.atexit = False

这里，只需要改变最后两行代码，运行不会有任何结果。这是因为设置atexit为False表示不调用这个回调。

需要注意的是，因为finalize跟踪了一个对象的一个引用，那么便会导致这个对象引用被保留，所以这个对象永远不会被垃圾回收。

代理

有时候使用代理比使用弱引用更方便。使用代理可以像使用原对象一样，而且不要求再访问对象之前先调用代理。

这说明，可以将代理传递到一个库，而这个库并不知道它接收的是一个引用而不是真正的对象。

示例如下：

import weakref

class MyObject:
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print('删除{}'.format(self))

obj = MyObject("MyObject")
r = weakref.ref(obj)
p = weakref.proxy(obj)

print('obj:', obj.name)
print('ref:', r().name)
print('proxy:', p.name)
del obj
print('proxy:', p.name)

运行之后，效果如下：

可以看到，如果引用对象已经被删除，那么再访问代理会产生一个ReferenceError异常。

缓存对象

ref和proxy类被认为是底层的。尽管它们对于维护单个对象的弱引用很有用，并且还支持对循环引用的垃圾回收。

但WeakKeyDictionary和WeakValueDictionary类为创建多个对象的缓存提供了一个更合适的API。

WeakValueDictionary类使用它包含的值的弱引用，当其他代码不再真正使用这些值时，则允许垃圾回收。

利用垃圾回收器的显式调用，下面展示了使用常规字典和WeakValueDictionary完成内存处理的区别。

import weakref
import gc
from pprint import pprint

gc.set_debug(gc.DEBUG_UNCOLLECTABLE)
class MyObject:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return 'MyObject---{}'.format(self.name)

    def __del__(self):
        print('删除---{}'.format(self))

def demo(cache_factory):
    all_refs = {}
    print('缓存类型：', cache_factory)
    cache = cache_factory()
    for name in ['one', 'two', 'three']:
        o = MyObject(name)
        cache[name] = o
        all_refs[name] = o
        del o
    print(" all_refs=", end='')
    pprint(all_refs)
    print("开始 缓存包括：", list(cache.keys()))
    for name, value in cache.items():
        print('{}={}'.format(name, value))
        del value
    print('清理')
    del all_refs
    gc.collect()
    print('结束 缓存包括：', list(cache.keys()))
    for name, value in cache.items():
        print('{}={}'.format(name, value))
    print("返回")
    return

demo(dict)
print()
demo(weakref.WeakValueDictionary)