首页 > 程序开发 > Web开发 > Python >

python垃圾回收机制

2017-06-10

python垃圾回收机制,现在的高级语言如java,c 等,都采用了垃圾收集机制,而不再是c,c++里用户自己管理维护内存的方式。自己管理内存极其自由,可以任意申请内存,但如同一把双刃剑,为大量内存泄露,悬空指针等bug埋下隐患。

python垃圾回收机制,现在的高级语言如java,c#等,都采用了垃圾收集机制,而不再是c,c++里用户自己管理维护内存的方式。自己管理内存极其自由,可以任意申请内存,但如同一把双刃剑,为大量内存泄露,悬空指针等bug埋下隐患。

对于一个字符串、列表、类甚至数值都是对象,且定位简单易用的语言,自然不会让用户去处理如何分配回收内存的问题。

python里也同java一样采用了垃圾收集机制,不过不一样的是,python采用的是引用计数机制为主,标记-清除和分代收集两种机制为辅的策略。

引用计数机制:

python里每一个东西都是对象,它们的核心就是一个结构体:PyObject

1typedefstruct_object {

2intob_refcnt;

3struct_typeobject *ob_type;

4}PyObject;

PyObject是每个对象必有的内容,其中ob_refcnt就是做为引用计数。当一个对象有新的引用时,它的ob_refcnt就会增加,当引用它的对象被删除,它的ob_refcnt就会减少

1#define Py_INCREF(op) ((op)->ob_refcnt++) //增加计数

2#define Py_DECREF(op) \ //减少计数

3if(--(op)->ob_refcnt != 0) \

4; \

5else\

6__Py_Dealloc((PyObject *)(op))

引用计数为0时,该对象生命就结束了。

引用计数机制的优点:

1、简单

2、实时性:一旦没有引用,内存就直接释放了。不用像其他机制等到特定时机。实时性还带来一个好处:处理回收内存的时间分摊到了平时。

引用计数机制的缺点:

1、维护引用计数消耗资源

2、循环引用

1list1=[]

2list2=[]

3list1.append(list2)

4list2.append(list1)

list1与list2相互引用,如果不存在其他对象对它们的引用,list1与list2的引用计数也仍然为1,所占用的内存永远无法被回收,这将是致命的。

对于如今的强大硬件,缺点1尚可接受,但是循环引用导致内存泄露,注定python还将引入新的回收机制。

上面说到python里回收机制是以引用计数为主,标记-清除和分代收集两种机制为辅。

1、标记-清除机制

标记-清除机制,顾名思义,首先标记对象(垃圾检测),然后清除垃圾(垃圾回收)。

首先初始所有对象标记为白色,并确定根节点对象(这些对象是不会被删除),标记它们为黑色(表示对象有效)。将有效对象引用的对象标记为灰色(表示对象可达,

但它们所引用的对象还没检查),检查完灰色对象引用的对象后,将灰色标记为黑色。重复直到不存在灰色节点为止。最后白色结点都是需要清除的对象。

2、回收对象的组织

这里所采用的高级机制作为引用计数的辅助机制,用于解决产生的循环引用问题。而循环引用只会出现在“内部存在可以对其他对象引用的对象”,比如:list,class等。

为了要将这些回收对象组织起来,需要建立一个链表。自然,每个被收集的对象内就需要多提供一些信息,下面代码是回收对象里必然出现的。

一个对象的实际结构。

通过PyGC_Head的指针将每个回收对象连接起来,形成了一个链表,也就是在1里提到的初始化的所有对象。

3、分代技术

分代技术是一种典型的以空间换时间的技术,这也正是java里的关键技术。这种思想简单点说就是:对象存在时间越长,越可能不是垃圾,应该越少去收集。

这样的思想,可以减少标记-清除机制所带来的额外操作。分代就是将回收对象分成数个代,每个代就是一个链表(集合),代进行标记-清除的时间与代内对象

存活时间成正比例关系。

从上面代码可以看出python里一共有三代,每个代的threshold值表示该代最多容纳对象的个数。默认情况下,当0代超过700,或1,2代超过10,垃圾回收机制将触发。

0代触发将清理所有三代,1代触发会清理1,2代,2代触发后只会清理自己。

下面是一个完整的收集流程:链表建立,确定根节点,垃圾标记,垃圾回收~

1、链表建立

首先,中里在分代技术说过:0代触发将清理所有三代,1代触发会清理1,2代,2代触发后只会清理自己。在清理0代时,会将三个链表(代)链接起来,清理1代的时,会链接1,2两代。在后面三步,都是针对的这个建立之后的链表。

2、确定根节点

图1为一个例子。list1与list2循环引用,list3与list4循环引用。a是一个外部引用。

对于这样一个链表,我们如何得出根节点呢。python里是在引用计数的基础上又提出一个有效引用计数的概念。顾名思义,有效引用计数就是去除循环引用后的计数。

下面是计算有效引用计数的相关代码:

01/* Set all gc_refs = ob_refcnt. After this, gc_refs is > 0 for all objects

02* in containers, and is GC_REACHABLE for all tracked gc objects not in

03* containers.

04*/

05staticvoid

06update_refs(PyGC_Head *containers)

07{

08PyGC_Head *gc = containers->gc.gc_next;

09for(; gc != containers; gc = gc->gc.gc_next) {

10assert(gc->gc.gc_refs == GC_REACHABLE);

11gc->gc.gc_refs = Py_REFCNT(FROM_GC(gc));

12assert(gc->gc.gc_refs != 0);

13}

14}

15

16/* A traversal callback for subtract_refs. */

17staticint

18visit_decref(PyObject *op,void*data)

19{

20assert(op != NULL);

21if(PyObject_IS_GC(op)) {

22PyGC_Head *gc = AS_GC(op);

23/* We're only interested in gc_refs for objects in the

24* generation being collected, which can be recognized

25* because only they have positive gc_refs.

26*/

27assert(gc->gc.gc_refs != 0);/* else refcount was too small */

28if(gc->gc.gc_refs > 0)

29gc->gc.gc_refs--;

30}

31return0;

32}

33

34/* Subtract internal references from gc_refs. After this, gc_refs is >= 0

35* for all objects in containers, and is GC_REACHABLE for all tracked gc

36* objects not in containers. The ones with gc_refs > 0 are directly

37* reachable from outside containers, and so can't be collected.

38*/

39staticvoid

40subtract_refs(PyGC_Head *containers)

41{

42traverseproc traverse;

43PyGC_Head *gc = containers->gc.gc_next;

44for(; gc != containers; gc=gc->gc.gc_next) {

45traverse = Py_TYPE(FROM_GC(gc))->tp_traverse;

46(void) traverse(FROM_GC(gc),

47(visitproc)visit_decref,

48NULL);

49}

50}

update_refs函数里建立了一个引用的副本。

visit_decref函数对引用的副本减1,subtract_refs函数里traverse的作用是遍历对象里的每一个引用,执行visit_decref操作。

最后,链表内引用计数副本非0的对象,就是根节点了。

说明:

1、为什么要建立引用副本?

答:这个过程是寻找根节点的过程,在这个时候修改计数不合适。subtract_refs会对对象的引用对象执行visit_decref操作。如果链表内对象引用了链表外对象,那么链表外对象计数会减1,显然,很有可能这个对象会被回收,而回收机制里根本不应该对非回收对象处理。

2、traverse的疑问(未解决)?

答:一开始,有个疑问。

然后gc指向list2,此时list2的副本(为0)不会减少,但是list2对list1还是存在实际上的引用,那么list1副本会减1吗?显然,如果减1就出问题了。

所以list1为0时,traverse根本不会再去处理list1这些引用(或者说,list2对list1名义上不存在引用了)。

此时,又有一个问题,如果存在一个外部对象b,对list2引用,subtract_refs函数中处理完list1后,当subtract_refs函数中遍历到list2时,list2的副本还会减1吗?显然traverse的作用还是没有理解。

3、垃圾标记

接下来,python建立两条链表,一条存放根节点,以及根节点的引用对象。另外一条存放unreachable对象。

标记的方法就是中里的标记思路,代码如下:

001/* A traversal callback for move_unreachable. */

002staticint

003visit_reachable(PyObject *op, PyGC_Head *reachable)

004{

005if(PyObject_IS_GC(op)) {

006PyGC_Head *gc = AS_GC(op);

007constPy_ssize_t gc_refs = gc->gc.gc_refs;

008

009if(gc_refs == 0) {

010/* This is in move_unreachable's 'young' list, but

011* the traversal hasn't yet gotten to it. All

012* we need to do is tell move_unreachable that it's

013* reachable.

014*/

015gc->gc.gc_refs = 1;

016}

017elseif(gc_refs == GC_TENTATIVELY_UNREACHABLE) {

018/* This had gc_refs = 0 when move_unreachable got

019* to it, but turns out it's reachable after all.

020* Move it back to move_unreachable's 'young' list,

021* and move_unreachable will eventually get to it

022* again.

023*/

024gc_list_move(gc, reachable);

025gc->gc.gc_refs = 1;

026}

027/* Else there's nothing to do.

028* If gc_refs > 0, it must be in move_unreachable's 'young'

029* list, and move_unreachable will eventually get to it.

030* If gc_refs == GC_REACHABLE, it's either in some other

031* generation so we don't care about it, or move_unreachable

032* already dealt with it.

033* If gc_refs == GC_UNTRACKED, it must be ignored.

034*/

035else{

036assert(gc_refs > 0

037|| gc_refs == GC_REACHABLE

038|| gc_refs == GC_UNTRACKED);

039}

040}

041return0;

042}

043

044/* Move the unreachable objects from young to unreachable. After this,

045* all objects in young have gc_refs = GC_REACHABLE, and all objects in

046* unreachable have gc_refs = GC_TENTATIVELY_UNREACHABLE. All tracked

047* gc objects not in young or unreachable still have gc_refs = GC_REACHABLE.

048* All objects in young after this are directly or indirectly reachable

049* from outside the original young; and all objects in unreachable are

050* not.

051*/

052staticvoid

053move_unreachable(PyGC_Head *young, PyGC_Head *unreachable)

054{

055PyGC_Head *gc = young->gc.gc_next;

056

057/* Invariants: all objects "to the left" of us in young have gc_refs

058* = GC_REACHABLE, and are indeed reachable (directly or indirectly)

059* from outside the young list as it was at entry. All other objects

060* from the original young "to the left" of us are in unreachable now,

061* and have gc_refs = GC_TENTATIVELY_UNREACHABLE. All objects to the

062* left of us in 'young' now have been scanned, and no objects here

063* or to the right have been scanned yet.

064*/

065

066while(gc != young) {

067PyGC_Head *next;

068

069if(gc->gc.gc_refs) {

070/* gc is definitely reachable from outside the

071* original 'young'. Mark it as such, and traverse

072* its pointers to find any other objects that may

073* be directly reachable from it. Note that the

074* call to tp_traverse may append objects to young,

075* so we have to wait until it returns to determine

076* the next object to visit.

077*/

078PyObject *op = FROM_GC(gc);

079traverseproc traverse = Py_TYPE(op)->tp_traverse;

080assert(gc->gc.gc_refs > 0);

081gc->gc.gc_refs = GC_REACHABLE;

082(void) traverse(op,

083(visitproc)visit_reachable,

084(void*)young);

085next = gc->gc.gc_next;

086}

087else{

088/* This *may* be unreachable. To make progress,

089* assume it is. gc isn't directly reachable from

090* any object we've already traversed, but may be

091* reachable from an object we haven't gotten to yet.

092* visit_reachable will eventually move gc back into

093* young if that's so, and we'll see it again.

094*/

095next = gc->gc.gc_next;

096gc_list_move(gc, unreachable);

097gc->gc.gc_refs = GC_TENTATIVELY_UNREACHABLE;

098}

099gc = next;

100}

101}

4、垃圾回收

回收的过程,就是销毁不可达链表内对象。下面代码就是list的清除方法:

01/* Methods */

02

03staticvoid

04list_dealloc(PyListObject *op)

05{

06Py_ssize_t i;

07PyObject_GC_UnTrack(op);

08Py_TRASHCAN_SAFE_BEGIN(op)

09if(op->ob_item != NULL) {

10/* Do it backwards, for Christian Tismer.

11There's a simple test case where somehow this reduces

12thrashing when a *very* large list is created and

13immediately deleted. */

14i = Py_SIZE(op);

15while(--i >= 0) {

16Py_XDECREF(op->ob_item[i]);

17}

18PyMem_FREE(op->ob_item);

19}

20if(numfree < PyList_MAXFREELIST && PyList_CheckExact(op))

21free_list[numfree++] = op;

22else

23Py_TYPE(op)->tp_free((PyObject *)op);

24Py_TRASHCAN_SAFE_END(op)

25}

相关文章
最新文章
热点推荐