Python深度探索（1）：内存管理机制

x = 10
y = 10
z = 10

print(id(x))
print(id(y))
print(id(z))

print(hex(id(x)))
print(hex(id(y)))
print(hex(id(z)))

print(x is y is z) # 输出结果：True

class MyClass:
pass
a = []
b = []
c = MyClass()
d = MyClass()
t1 = (1,2,3)
t2 = (1,2,3)
print(a is b) # False 元素个数和类型相同的列表不会使用同一个内存空间（小柜子）
print(c is d) # False MyClass类的不同实例不会使用同一个内存空间（小柜子）
print(t1 is t2) # True 元素个数和类型相同的元组会使用同一个内存空间（小柜子）

from sys import getrefcount
 
a = [1, 2, 3]
print(getrefcount(a)) # 输出2
 
b = a
print(getrefcount(b)) # 输出3
print(getrefcount(a)) # 输出3
 
x = 1
print(getrefcount(x)) #输出1640
y = 1
print(getrefcount(x)) # 输出1641
print(getrefcount(y)) # 输出1641

from sys import getrefcount
 
# 类的构造方法传入另外一个对象的引用
class MyClass(object):
def __init__(self, other_obj):
self.other_obj = other_obj # 这里的other_obj与后面的data指向了同一块内存地址
 
data = {‘name‘:‘Bill‘,‘Age‘:30}
print(getrefcount(data)) # 输出2
my = MyClass(data)
print(id(my.other_obj)) # 输出4364264288
print(id(data)) #输出4364264288
 
print(getrefcount(data)) # 输出3
 
在Python中，一切都是对象，包括值。如1、2、3、"abcd"等。所以Python会在使用这些值时，先将其保存在一块固定的内存区域，然后将所有赋给这些值的变量指向这块内存区域，同时引用计数器加1。
 
例如，
a = 1
b = 1
 
其中a和b指向了同一块内存空间，这两个变量其实都保存了对1的引用。使用id函数查看这两个变量的引用地址是相同的。
 
4. 循环引用与拓扑图
 
如果对象引用非常多，就可能会构成非常复杂的拓扑结果。例如，下面代码的引用拓扑关系就非常复杂。估计大多数同学都无法一下子看出这段程序中各个对象的拓扑关系。
 

class MyClass1:
def __init__(self, obj):
self.obj = obj
 
class MyClass2:
def __init__(self,obj1,obj2):
self.obj1 = obj1
self.obj2 = obj2
 
data1 = [‘hello‘, ‘world‘]
data2 = [data1, MyClass1(data1),3,dict(data = data1)]
data3 = [data1,data2,MyClass2(data1,data2),MyClass1(MyClass2(data1,data2))]

import objgraph
objgraph.show_refs([data3], filename=‘对象引用关系.png‘)

如果对象之间互相引用，有可能会形成循环引用。也就是a引用b，b引用a，见下面的代码。

 

import objgraph
from sys import getrefcount
a = {}
b = {‘data‘:a}
a[‘value‘] = b
objgraph.show_refs([b], filename=‘循环引用1.png‘)

 

在这段代码中。a和b都是一个字典，b中的一个value引用了a，而a的一个value引用了b，所以产生了一个循环引用。这段代码的引用拓扑图如下：

 

很明显，这两个字典是循环引用的。

不光是多个对象之间的引用可以产生循环引用，只有一个对象也可以产生循环引用，代码如下：

 

a = {}
a[‘value‘] = a
a = []
a.append(a)
print(getrefcount(a))
objgraph.show_refs([a], filename=‘循环引用2.png‘)

 

在这段代码中，字典a的一个值是自身，拓扑图如下：

 

5. 减少引用计数的两种方法

 

前面一直说让引用计数器增加的方法，那么如何让引用计数器减少呢？通常有如下两种方法：

（1）用del删除某一个引用

（2）将变量指向另外一个引用，或设置为None，也就是引用重定向。

 

 

（1）用del删除某一个引用

 

del语句可以删除一个变量对某一个块内存空间的引用，也可以删除集合对象中的某个item，代码如下：

 

from sys import getrefcount
 
person = {‘name‘:‘Bill‘,‘age‘:40}
person1 = person
print(getrefcount(person1)) # 输出3
 
del person # 删除person对字典的引用
print(getrefcount(person1)) # 由于引用少了一个，所以输出为2
# print(person) # 抛出异常 # 被删除的变量相当于重来没定义过，所以这条语句会抛出异常
 
del person1[‘age‘] # 删除字典中key为age的值对
print(person1)
 
（2）引用重定向

from sys import getrefcount
 
value1 = [1,2,3,4]
value2 = value1
value3 = value2
print(getrefcount(value2)) # 输出4
value1 = 20
print(getrefcount(value2)) # 输出3，因为value1重新指向了20
value3 = None
print(getrefcount(value2)) # 输出2，因为value3被设置为None，也就是不指向任何内存空间，相当于空指针

 

6. 垃圾回收

 

像Java、JavaScript、Python这样的编程语言，都不允许直接通过代码释放变量占用的内存，虚拟机会自动释放这些内存区域。所以很多程序员就会认为在这些语言中可以放心大胆地申请各种类型的变量，并不用担心变量的释放问题，因为系统会自动替我们完成这些烦人的工作。

 

没错，这些语言的虚拟机会自动释放一些不需要的内存块，用专业术语描述就是：垃圾回收。 相当于为系统减肥或减负。因为不管你的计算机有多少内存，只要不断创建新的变量，哪怕该变量只占用了1个字节的内存空间，内存也有用完的一天。所以虚拟机会在适当的时候释放掉不需要的内存块。

 

 

在前面已经提到过，虚拟机会回收引用计数为0的内存块，因为这些内存块没有任何变量指向他们，所以留着没有任何意义。那么到底虚拟机在什么时候才会回收这些内存块呢？通常来讲，虚拟机会设置一个内存阈值，一旦超过了这个阈值，就会自动启动垃圾回收器来回收不需要的内存空间。对于不同编程语言的这个阈值是不同的。对于Python来说，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。

 

我们可以通过gc模块的get_threshold()方法，查看该阈值:

import gc
print(gc.get_threshold())

 

输出的结果为：

(700, 10, 10)

 

这个700就是这个阈值。后面的两个10是与分代回收相关的阈值，后面会详细介绍。可以使用gc模块中的set_threshold方法设置这个阈值。

 

由于垃圾回收是一项昂贵的工作，所以如果计算机的内存足够大，可以将这个阈值设置的大一点，这样可以避免垃圾回收器频繁调用。

 

当然，如果觉得必要，也可以使用下面的代码手工启动垃圾回收器。不过要注意，手工启动垃圾回收器后，垃圾回收器也不一定会立刻启动，通常会在系统空闲时启动垃圾回收器。

 

gc.collect()

 

7. 变量不用了要设置为None

 

 

有大量内存被占用，是一定要被释放的。但释放这些内存有一个前提条件，就是这个内存块不能有任何变量引用，也就是引用计数器为0。如果有多个变量指向同一个内存块，而且有一些变量已经不再使用了，一个好的习惯是将变量设置为None，或用del删除该变量。

 

person = {‘Name‘:‘Bill‘}
value = [1,2,3]
del person
value = None

 

当删除person变量，以及将value设置为None后，就不会再有任何变量指向字典和列表了，所以字典和列表占用的内存空间会被释放。

 

8. 解决循环引用的回收问题

 

在前面讲了Python GC（垃圾回收器）的一种算法策略，就是引用计数法，这种方法是Python GC采用的主要方法。不过这种策略也有其缺点。下面就看一下引用计数法的优缺点。

 

优点：简单，实时（一旦为0就会立刻释放内存空间，毫不犹豫）

 

缺点： 维护性高（简单实时，但是额外占用了一部分资源，虽然逻辑简单，但是麻烦。好比你吃草莓，吃一次洗一下手，而不是吃完洗手。），不能解决循环引用的问题。

 

那么Python到底是如何解决循环引用释放的问题呢？先看下面的代码。

 

import objgraph
from sys import getrefcount
a = {}
b = {‘data‘:a}
a[‘value‘] = b
del a
del b

 

在这段代码中，很明显，a和b互相引用。最后通过del语句删除a和b。由于a和b是循环引用，如果按前面引用计数器的方法，在删除a和b之前，两个字典分别由两个引用（引用计数器为2），一个是自身引用，另一个是a或b中的value引用的自己。如果只是删除了a和b，似乎这两个字典各自还剩一个引用。但其实这两个字典的内存空间已经释放。那么Python是如何做到的呢？

 

其实Python GC在检测所有引用时，会检测哪些引用之间是循环引用，如果检测到某些变量之间循环引用，例如，a引用b，b引用a，就会在检测a时，将b的引用计数器减1，在检测b时，会将a的引用计数器减1。也就是说，Python GC当发现某些引用是循环引用后，会将这些引用的计数器多减一个1。所以这些循环引用指向的空间仍然会被释放。

 

9. 分代回收

 

如果是多年的朋友，或一起做了多年的生意，有多年的业务往来，往往会产生一定的信任。通常来讲，合作的时间越长，产生的信任感就会越深。Python GC采用的垃圾回收策略中，也会使用这种信任感作为辅助算法，让GC运行得更有效率。这种策略就是分代（generation）回收。

 

 

 

 

分代回收的策略有一个基本假设，就是存活的越久，越可能被经常使用，所以出于信任和效率，对这些“长寿”对象给予特殊照顾，在GC对所有对象进行检测时，就会尽可能少地检测这些“长寿”对象。就是现在有很多企业是免检企业一样，政府出于对这些企业的信任，给这些企业生产出的产品予以免检的特殊优待。

 

那么Python对什么样的对象会给予哪些特殊照顾呢？Python将对象共分为3代，分别用0、1、2表示。任何新创建的对象是0代，不会给予任何特殊照顾，当某一个0代对象经过若干次垃圾回收后仍然存活，那么就会将这个对象归入1代对象，如果这个1代对象，再经过若干次回收后，仍然存活，就会将该对象归为2代对象。

 

在前面的描述中，涉及到一个“若干次”回收，那么这个“若干次”是指什么呢？在前面使用get_threshold函数获取阈值时返回了(700,10,10），这个700就是引用计数策略的阈值，而后面的两个10与分代策略有关。第1个10是指第0代对象经过了10次垃圾回收后仍然存在，就会将其归为第1代对象。第2个10是指第1代对象经过了10次垃圾回收后仍然存在，就会将其归为第2代对象。也就是说，GC需要执行100次，才会扫描到第2代对象。当然，也可以通过set_threshold函数来调整这些值。

import gc gc.set_threshold(600, 5, 6)

总结

 

本文主要讲了Python如何自动释放内存。主要有如下3种策略：

1. 引用计数策略（为0时释放）

2. 循环引用策略（将相关引用计数器多减1）

3. 分代策略（解决了GC的效率问题）

 

通过这些策略的共同作用，可以让Python更加有效地管理内存，更进一步地提高Python的性能。

 

获取更多学习资源，可以关注“极客起源”公众号