首页 > > 网络编程 > 其它 >

python的内存管理机制

2018-06-18 01:49:23来源：未知阅读 ()

　　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!'