python采用"引用计数"和"垃圾回收"两种机制来管理内存。引用计数通过记录对象被引用的次数来管理对象。对对象的引用都会使得引用计数加1,移除对对象的引用,引用计数则会减1,当引用计数减为0时,对象所占的内存就会被释放掉。引用计数可以高效的管理对象的分配和释放,但是有一个缺点,就是无法释放引用循环的对象。

最简单的就是下面的自己引用自己的例子:

def make_cycle():  
    l = [ ]  
    l.append(l)  
make_cycle()  

垃圾回收机制会根据内存的分配和释放情况的而被调用,比如分配内存的次数减去释放内存的次数大于某一个阈值的时候。如下所示,我们可以通过gc对象来获取阈值:

>>> gc.get_threshold()
(700, 10, 10)

当内存溢出时,不会自动调用garbage collection( gc ),因为gc更看重的是垃圾对象的个数, 而不是大小。对于长时间运行的程序,尤其是一些服务器应用,人为主动的调用gc是非常有必要的,如下代码所示:

import sys, gc  
def make_cycle():  
    l = {}  
    l[0] = l  
def main():  
    collected = gc.collect()  
    print "Garbage collector: collected %d objects." % (collected)  
    print "Creating cycles..."  
    for i in range(10):  
        make_cycle()  
    collected = gc.collect()  
    print "Garbage collector: collected %d objects." % (collected)  
if __name__ == "__main__":  
    ret = main()  
    sys.exit(ret)

调用gc的策略有两种,一种是固定时间间隔进行调用,另一种是基于事件的调用。如1,用户终止了对应用的访问,2,明显监测到应用进入到闲置的状态,3,运行高性能服务前后,4,周期性、或阶段性工作的前后。注意gc虽好,但也不能常用,毕竟还是会消耗一定的计算资源。

gc垃圾回收方法(寻找引用循环对象):

可以发现,只有容器对象才会出现引用循环,比如列表、字典、类、元组。首先,为了追踪容器对象,需要每个容器对象维护两个额外的指针,用来将容器对象组成一个链表,指针分别指向前后两个容器对象,方便插入和删除操作。其次,每个容器对象还得添加gc_refs字段。

一次gc垃圾回收步骤:

1,使得gc_refs等于容器对象的引用计数。
2,遍历每个容器对象(a),找到它(a)所引用的其它容器对象(b),将那个容器对象(b)的gc_refs减去1。
3,将所有gc_refs大于0的容器对象(a)取出来,组成新的队列,因为这些容器对象被容器对象队列的外部所引用。
4,任何被新队列里面的容器对象,所引用的容器对象(旧队列中)也要加入到新队列里面。
5,释放旧队列里面的剩下的容器对象。(释放容器对象时,它所引用的对象的引用计数也要减1)

gc分代机制:

gc采用分代(generations)的方法来管理对象,总共分为三代(generation 0,1,2)。新产生的对象放到第0代里面。如果该对象在第0代的一次gc垃圾回收中活了下来,那么它就被放到第1代里面。如果第1代里面的对象在第1代的一次gc垃圾回收中活了下来,它就被放到第2代里面。

gc.set_threshold(threshold0[, threshold1[, threshold2]])

设置gc每一代垃圾回收所触发的阈值。从上一次第0代gc后,如果分配对象的个数减去释放对象的个数大于threshold0,那么就会对第0代中的对象进行gc垃圾回收检查。从上一次第1代gc后,如过第0代被gc垃圾回收的次数大于threshold1,那么就会对第1代中的对象进行gc垃圾回收检查。同样,从上一次第2代gc后,如过第1代被gc垃圾回收的次数大于threshold2,那么就会对第2代中的对象进行gc垃圾回收检查。如果threshold0设置为0,表示关闭分代机制。

最后的bug:__del__方法:

我们知道当引用计数变为0的时候,会先调用对象的__del__方法,然后再释放对象。但是当一个引用循环中对象有__del__方法时,gc就不知道该以什么样的顺序来释放环中对象。因为环中的a对象的__del__方法可能调用b对象,而b对象的__del__方法也有可能调用a对象。所以需要人为显式的破环。

import gc  
class A(object):  
    def __del__(self):  
        print '__del__ in A'  
class B(object):  
    def __del__(self):  
        print '__del__ in B'           
class C(object):  
    pass             
if __name__=='__main__':  
    print 'collect: ',gc.collect()  
    print 'garbage: ',gc.garbage  
    a = A()  
    b = B()  
    c = C()  
    a.cc = c  
    c.bb = b  
    b.aa = a  
    del a,b,c  
    print 'collect: ',gc.collect()  
    print 'garbage: ',gc.garbage  
    del gc.garbage[0].cc # 当然,这是在我们知道第一个对象是 a的情况下,手动破除引用循环中的环  
    del gc.garbage[:] # 消除garbage对a和b对象的引用,这样引用计数减1等于0,就能回收a、b、c三个对象了  
    print 'garbage: ',gc.garbage  
    print '----------------------------'  
    print 'collect: ',gc.collect()  
    print 'garbage: ',gc.garbage

如上所示:调用一次gc.collect(),首先检查因为引用循环而不可达对象,如果一个引用循环中所有对象都不包含__del__方法,那么这个引用循环中的对象都将直接被释放掉。否则,将引用循环中包含__del__方法的对象加入到gc.garbage列表中。(这时它们的引用计数也会加1,因此gc.collect()不会再对这个环进行处理)

用户通过gc.garbage来获取这些对象,手动消除引用,进行破环。最后消除gc.garbage对这些对象的引用,这时这些对象的引用计数减1等于0,就自动被回收了。否则由于gc.garbage对这些对象存在引用,这些对象将永远不会被回收。

其他:

import weakref  
class Foo(object):  
    pass  
a = Foo()  
a.bar = 123  
a.bar2 = 123  
  
  
del a  
del a.bar2  
  
  
b = weakref.ref(a)  
print b().bar  
print a == b()  
  
  
c = weakref.proxy(a)  
print c.bar  
print c == a

del:只是使变量所代表的对象的引用计数减1,并在对应空间中删除该变量名。

weak.ref:会返回a对象的引用,但是不会让a对象的引用计数加1。但是每次都得通过b()来获取a对象。

weak.proxy:相对于weakref.ref更透明的可选操作,即直接通过c就获取a对象。

闭包空间的变量和自由变量的释放问题:

class A(object):  
    def __init__(self,name):  
        self._name = name  
    def __del__(self):  
        print '__del__ in ',self._name       
def f1():  
    a = A('a')  
    b = A('b')  
    def f2():  
        c = A('c')  
        print a  
    return f2              
if __name__=='__main__':  
    print 'f2 = f1():'  
    f2 = f1()  
    print '\na.__closure__:'  
    print f2.__closure__ # 查看f2的闭包里面引用了a对象  
    print '\na():'  
    f2()  
    print '\ndel f2:'  
    del f2 # 此时已经没有任何变量可以引用到返回的f2对象了。  
    print '\nover!'