Python 垃圾收集
Python解释器对正在使用的对象保持计数。当对象不再被引用指向的时候，垃圾收集器可以释放该对象，获取分配的...
Python解释器对正在使用的对象保持计数。当对象不再被引用指向的时候，垃圾收集器可以释放该对象，获取分配的内存。例如，如果你使用常规的Python(CPython, 不是JPython)时，Python的垃圾收集器将调用free()/delete()
实用工具
资源（resource）
resource’ 模块用来查看项目当前得的固有的)内存消耗
[固有内存是项目实际使用的RAM]
1
>>>
import
resource
2
>>> resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
3
4332
对象（objgraph）
objgraph’ 是一个实用模块,可以展示当前内存中存在的对象
[objgraph 文档和实例地址: https://mg.pov.lt/objgraph/]来看看objgraph的简单用法:
01
import
objgraph
02
import
random
03
import
inspect
04
05
class
Foo(
object
):
06
def
__init__(
self
):
07
self
.val
=
None
08
09
def
__str__(
self
):
10
return
“foo – val: {0
}”.
format
(
self
.val)
11
12
def
f():
13
l
=
[]14
for
i
in
range
(
3
):
15
foo
=
Foo()
16
#print “id of foo: {0}”.format(id(foo))17
#print “foo is: {0}”.format(foo)18
l.append(foo)
19
20
return
l
21
22
def
main():
23
d
=
{}24
l
=
f()
25
d[‘k’] =
l
26
“
list
l has {0
} objects of
type
Foo()”
.
format
(
len
(l))
27
28
objgraph.show_most_common_types()
29
objgraph.show_backrefs(random.choice(objgraph.by_type(‘Foo’)),
30
filename
=
“foo_refs.png”)
31
32
objgraph.show_refs(d, filename
=
‘sample
-
graph.png’)
33
34
if
__name__
=
=
“__main__”:
35
main()
36
python test1.py
37
38
list
l has
10000
objects of
type
Foo()
39
dict
10423
40
Foo
10000
————> Guilty as charged!
41
tuple
3349
42
wrapper_descriptor
945
43
function
860
44
builtin_function_or_method
616
45
method_descriptor
338
46
weakref
199
47
member_descriptor
161
48
getset_descriptor
107注意，我们在内存中还持有10,423个‘dict’的实例对象。
可视化objgraph依赖项
Objgraph有个不错的功能，可以显示Foo()对象在内存中存在的因素，即，显示谁持有对它的引用 (在这个例子中是list ‘l’)。在RedHat/Centos上, 你可以使用sudo yum install yum install graphviz*安装graphviz
如需查看对象字典，d，请参考:
objgraph.show_refs(d, filename=’sample-graph.png’)
从内存使用角度来看，我们惊奇地发现——为什么对象没有释放?这是因为有人在持有对它的引用。
这个小片段展示了objgraph怎样提供相关信息:
1
objgraph.show_backrefs(random.choice(objgraph.by_type(‘Foo’)),
2
filename
=
“foo_refs.png”)
在这一案例中, 我们查看了Foo类型的随机对象。我们知道该特定对象被保存在内存中，因其引用链接在指定范围内。
有时，以上技巧能帮助我们理解，为什么当我们不再使用某对象时，Python垃圾回收器没有将垃圾回收。
难处理的是，有时候我们会发现Foo()占用了很多内存的类。这时我们可以用heapy()来回答以上问题。
Heapy
heapy 是一个实用的，用于调试内存消耗/泄漏的工具。查看 http://guppy-pe.sourceforge.net/。通常，我将objgraph和heapy搭配使用：用 heapy 查看分配对象随时间增长的差异，heapy能够显示对象持有的最大内存等；用Objgraph找backref链（例如：前4节），尝试获取它们不能被释放的原因。Heapy的典型用法是在不同地方的代码中调用一个函数，试图为内存使用量提供大量收集线索，找到可能会引发的问题：
01
from
guppy
import
hpy
02
03
def
dump_heap(h, i):
04
“””
05
@param h: The heap (
from
hp
=
hpy(), h
=
hp.heap())
06
@param i: Identifier
str
07
“””
08
09
“Dumping stats at: {0
}”.
format
(i)
10
‘Memory usage: {0
} (MB)’.
forma
t
(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
/
1024
)
11
“Most common types:”
12
objgraph.show_most_common_types()
13
14
“heap
is
:”
15
“{0
}”.
format
(h)
16
17
by_refs
=
h.byrcs
18
“by references: {0
}”.
format
(by_refs)
19
20
“More stats
for
top element..”
21
“By clodo (
class
or
dict
owner): {0
}”
.
format
(by_refs[0
].byclodo)
22
“By size: {0
}”.
format
(by_refs[0
].bysize)
23
“By
id
: {0
}”.
format
(by_refs[0
].byid)
减少内存消耗小技巧
在这一部分，我会介绍一些自己发现的可减少内存消耗的小窍门.Slots
当你有许多对象时候可以使用Slots。Slotting传达给Python解释器：你的对象不需要动态的字典(从上面的例子2.2中，我们看到每个Foo()对象内部包含一个字典)用slots定义你的对象，让python解释器知道你的类属性/成员是固定的.。这样可以有效地节约内存!
参考以下代码:
01
import
resource
02
class
Foo(
object
):
03
#__slots__ = (‘val1’, ‘val2’, ‘val3’, ‘val4’, ‘val5’,
‘val6’)
04
05
def
__init__(
self
, val):
06
self
.val1
=
val
+
1
07
self
.val2
=
val
+
2
08
self
.val3
=
val
+
3
09
self
.val4
=
val
+
4
10
self
.val5
=
val
+
5
11
self
.val6
=
val
+
6
12
13
def
f(count):
14
l
=
[]15
16
for
i
in
range
(count):
17
foo
=
Foo(i)
18
l.append(foo)
19
20
return
l
21
22
def
main():
23
count
=
10000
24
l
=
f(count)
25
26
mem
=
resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
27
“Memory usage
is
: {0
} KB”.
format
(mem)
28
“Size per foo obj: {0
} KB”.
forma
t
(
float
(mem)
/
count)
29
30
if
__name__
=
=
“__main__”:
31
main()
32
33
34
[vagrant@datosdev temp]$ python test2.py35
Memory usage
is
:
16672
KB
36
Size per foo obj:
1.6672
KB
37
38
Now un
-
comment this line:
#__slots__ =
(‘val1’, ‘val2’, ‘val3’, ‘val4’, ‘val5’, ‘val6’)
39
40
[vagrant@datosdev temp]$ python test2.py41
Memory usage
is
:
6576
KB
42
Size per foo obj:
0.6576
KB在这个例子中，减少了60%的内存消耗！
更多Slotting的信息，请点击链接: http://www.elfsternberg.com/2009/07/06/python-what-the-hell-is-a-slot/
驻留：谨防驻留字符串！
Python会记录如字符串等不可改变的值（其每个值的大小依赖于实现方法），这称为驻留。1
>>> t
=
“abcdefghijklmnopqrstuvwxyz”
2
>>> p
=
“abcdefghijklmnopqrstuvwxyz”
3
>>>
id
(t)
4
139863272322872
5
6
>>>
id
(p)
7
139863272322872这是由python解析器完成的，这样做可以节省内存，并加快比较速度。例如，如果两个字符串拥有相同的ID或引用--他们就是全等的。
然而，如果你的程序创建了许多小的字符串，你的内存就会出现膨胀。
生成字符串时使用Format来代替“+”
接下来，在构造字符串时，使用Format来代替“+”构建字符串。亦即，
1
st
=
“{0
}_{1
}_{2
}_{3
}”.
format
(a,b,c,d)
# 对内存更好，不创建临时变量st
2
st2
=
a
+
‘_’
+
b
+
‘_’
+
c
+
‘_’
+
d
# 在每个“+”时创建一个临时str，这些都是驻留在内存中的。
在我们的系统中，当我们将某些字符串构造从“+”变为使用format时，内存会明显被节省。
关于系统级别
上面我们讨论的技巧可以帮助你找出系统内存消耗的问题。但是，随着时间的推移，python进程产生的内存消耗会持续增加。这似乎与以下问题有关:- 为什么C中内存分配能够在Python内部起作用，这本质上是内存碎片导致的。因为，除非整个内存没有使用过，否则该分配过程不能调用‘free’方法。但需要注意的是，内存的使用不是根据你所创建和使用的对象来进行排列。
- 内存增加也和上面讨论的“Interning” 有关。
总结
归纳了一些减少python进程消耗内存的技巧，当我们在代码中寻找内存泄漏时，一种方法是通过使用Heapy找出哪些Obj占用了较多内存，然后通过使用Objgraph找出内存被释放的原因（除非你认为他们本应该被释放）。总的来说，觉得在python中寻找内存问题是一种修行。随着时间的积累，对于系统中的内存膨胀和泄漏问题，你能产生一种直觉判断，并能更快地解决它们。愿你在发现问题的过程中找到乐趣！
周一就是烧脑日，欢迎进入工作状...
关注 北大青鸟北大公学校区
微信扫一扫关注公众号
