Python内存管理机制详谈（python中的内存管理）

Python内存管理机制详谈（python中的内存管理）

一、变量与对象

导语：a = 1

整数1为一个对象。而a是一个引用。利用赋值语句，引用a指向对象1。Python是动态类型的语言(参考动态类型)，对象与引用分离。Python像使用“筷子”那样，通过引用来接触和翻动真正的食物——对象。

1、变量

通过变量指针引用对象；变量指针指向具体对象的内存空间，取对象的值。

2、对象

类型已知，每个对象都包含一个头部信息（头部信息：类型标识符和引用计数器）【对象自带的类型标识符决定对象类型】

变量名没有类型，类型属于对象（因为变量引用对象，所以类型随对象），变量引用什么类型的对象，变量就是什么类型的。

In [32]: var1=objectIn [33]: var2=var1In [34]: id(var1)Out[34]: 139697863383968In [35]: id(var2)Out[35]: 139697863383968PS：id()是python的内置函数，用于返回对象的身份，即对象的内存地址。

In [39]: a=123In [40]: b=aIn [41]: id(a)Out[41]: 23242832In [42]: id(b)Out[42]: 23242832Ps：a和b指向同一个对象的内存地址In [43]: a=456In [44]: id(a)Out[44]: 33166408In [45]: id(b)Out[45]: 23242832Ps：a变量重新指向（引用）了另一个对象，不同对象的内存地址当然不一样注意： 对象引用对象，是Python最基本的构成方式。即使是a = 1这一赋值方式，实际上是让词典的一个键值"a"的元素引用整数对象1。该词典对象用于记录所有的全局引用。该词典引用了整数对象1。我们可以通过内置函数globals()来查看该词典。

from sys import getrefcounta = [1, 2, 3]print(getrefcount(a)) b = [a, a]print(getrefcount(a))由于对象b引用了两次a，a的引用计数增加了2

3、引用所指判断【is 判断的是两个变量指向的对象的内存地址是否是同一个地址，是同一个地址返回Ture，否则返回False】

衍生：在python中 is 和 == 的区别：在 Python 中一切都是对象，对象之间比较是否相等可以用==，也可以用is。①is：比较的是两个对象的id值是否也相等，也就是比较两个对象是否为同一个实例对象，是否指向同一个内存地址。②==：双等于号比较的是两个对象的内容是否相等，默认会调用对象的 __eq__ 方法。

通过is进行引用所指判断，is是用来判断两个引用所指的对象是否相同。

为了检验两个引用指向同一个对象，我们可以用is关键字。is用于判断两个引用所指的对象是否相同。

整数In [46]: a=1In [47]: b=1In [48]: print(a is b)True

短字符串In [49]: c="good"In [50]: d="good"In [51]: print(c is d)True

长字符串：简单理解，纯字母、数字或者下划线的组合 就是短字符串，其他是长字符串In [52]: e="very good"In [53]: f="very good"In [54]: print(e is f)Ture

列表In [55]: g=[]In [56]: h=[]In [57]: print(g is h)False

由运行结果可知：

1、Python没有缓存列表及其他对象，可以由多个相同的对象，可以使用赋值语句创建出新的对象

2、在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于1的引用时，实际上是让所有这些引用指向同一个对象。

3、由于Python缓存了整数和短字符串，因此每个对象只存有一份【对象在内存中的地址相同】。比如，所有整数1的引用都指向同一对象。即使使用赋值语句，也只是创造了新的引用，而不是对象本身。长的字符串和其它对象可以有多个相同的对象，可以使用赋值语句创建出新的对象。

二、引用计数

在Python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。

使用sys包中的getrefcount()，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。

查看对象的引用计数：sys.getrefcount()

1、普通引用

In [2]: import sysIn [3]: a=[1,2,3]In [4]: getrefcount(a)Out[4]: 2In [5]: b=aIn [6]: getrefcount(a)Out[6]: 3In [7]: getrefcount(b)Out[7]: 3Ps：当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。

2、容器对象

Python的一个容器对象(container)，比如列表、字典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。【可以理解为引用对象的变量】

In [12]: a=[1,2,3,4,5]In [13]: b=aIn [14]: a is bOut[14]: TrueIn [15]: a[0]=6 In [16]: aOut[16]: [6, 2, 3, 4, 5]In [17]: a is bOut[17]: TrueIn [18]: bOut[18]: [6, 2, 3, 4, 5]

由上可见，实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。

3、引用计数增加

1、对象被创建In [39]: getrefcount(123)Out[39]: 6In [40]: n=123In [41]: getrefcount(123)Out[41]: 7

2、另外的别人被创建In [42]: m=nIn [43]: getrefcount(123)Out[43]: 8

3、作为容器对象的一个元素In [44]: a=[1,12,123]In [45]: getrefcount(123)Out[45]: 9

4、被作为参数传递给函数：foo(x)

4、引用计数减少

1、对象的别名被显式的销毁In [46]: del mIn [47]: getrefcount(123)Out[47]: 8

2、对象的一个别名被赋值给其他对象In [48]: n=456In [49]: getrefcount(123)Out[49]: 7

3、对象从一个窗口对象中移除，或，窗口对象本身被销毁In [50]: a.remove(123)In [51]: aOut[51]: [1, 12]In [52]: getrefcount(123)Out[52]: 6

4、一个本地引用离开了它的作用域，比如上面的foo(x)函数结束时，x指向的对象引用减1。

总结：增加对象引用计数器和减少引用计数器的几种方式：1、有4种方式，会增加引用计数器　　　　　　①创建对象---如：X=1　　　　　　②别名被创建---如：赋值 y=x【赋值给其他变量】　　　　　　③做为参数传递给函数---如：参数名（x）　　　　　　④成为容器对象的一个元素---如：List=[x, y,‘ss’]

2、什么情况下会减少引用???　　　　　　①本地引用被赋值为其他对象---当对象1被创建并赋值给X，它的引用就为1，当增加了别名（应该也可以成为赋值），引用就变成了2（Y的引用就为2），不过当x被重新赋值2，x对应的引用计数就减1. 如果某个引用指向对象A，当这个引用被重新定向到某个其他对象B时，对象A的引用计数减少:

from sys import getrefcounta = [1, 2, 3]b = aprint(getrefcount(b))a = 1print(getrefcount(b))

②对象名被销毁---使用del x ,这是引用计数就为0 　　　　　　　　del也可以用于删除容器元素中的元素

a = [1,2,3]del a[0]print(a)

③对象从一个窗口对象移除---函数名.Remove()【窗口对象如列表，字典，元组等】

④窗口对象被销毁---如:List=[x,y,'ss'] Del list[]【窗口对象被销毁，代表窗口对象中包含的所有对象都被销毁】

三、垃圾回收【当某对象引用计数器变为0时，此时应该被垃圾回收】

当Python中的对象越来越多，占据越来越大的内存，启动垃圾回收(garbage collection)，将没用的对象清除。

1、原理

当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾。比如某个新建对象，被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。

In [74]: a=[321,123]In [75]: del a

2、解析del

del a后，已经没有任何引用指向之前建立的[321,123]，该列表引用计数变为0，用户不可能通过任何方式接触或者动用这个对象，当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。

3、注意

1、垃圾回收时，Python不能进行其它的任务，频繁的垃圾回收将大大降低Python的工作效率；

2、Python只会在特定条件下，自动启动垃圾回收（垃圾对象少就没必要回收）

3、当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。

4、垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为0。

In [93]: import gcIn [94]: gc.get_threshold()　　#gc模块中查看阈值的方法Out[94]: (700, 10, 10)

阈值分析：

700即是垃圾回收启动的阈值；

每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收；

当然也是可以手动启动垃圾回收：

In [95]: gc.collect() #手动启动垃圾回收Out[95]: 2

4、何为分代回收

Python将所有的对象分为0，1，2三代；

所有的新建对象都是0代对象；

当某一代对象经历过垃圾回收，依然存活，就被归入下一代对象。

四、内存池机制

Python中有分为大内存和小内存：（256K为界限分大小内存）【>256k为大内存，<256k为小内存】

1、大内存使用malloc进行分配

2、小内存使用内存池进行分配

3、Python的内存池(金字塔)

第3层：最上层，用户对Python对象的直接操作

第1层和第2层：内存池，有Python的接口函数PyMem_Malloc实现-----若请求分配的内存在1~256字节之间就使用内存池管理系统进行分配，调用malloc函数分配内存，但是每次只会分配一块大小为256K的大块内存，不会调用free函数释放内存，将该内存块留在内存池中以便下次使用。

第0层：大内存-----若请求分配的内存大于256K，malloc函数分配内存，free函数释放内存。

第-1，-2层：操作系统进行操作

Python垃圾回收的另一种讲解

垃圾回收：

1、吃太多，总会变胖，Python也是这样。当Python中的对象越来越多，它们将占据越来越大的内存。不过你不用太担心Python的体形，它会乖巧的在适当的时候“减肥”，启动垃圾回收(garbage collection)，将没用的对象清除。在许多语言中都有垃圾回收机制，比如Java和Ruby。尽管最终目的都是塑造苗条的提醒，但不同语言的减肥方案有很大的差异 (这一点可以对比本文和Java内存管理与垃圾回收)。

2、从基本原理上，当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。比如某个新建对象，它被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。比如下面的表:

a = [1, 2, 3]

del a

del a后，已经没有任何引用指向之前建立的[1, 2, 3]这个表。用户不可能通过任何方式接触或者动用这个对象。这个对象如果继续待在内存里，就成了不健康的脂肪。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。

3、然而，减肥是个昂贵而费力的事情。垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。

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

import gc

print(gc.get_threshold())

返回(700, 10, 10)，后面的两个10是与分代回收相关的阈值，后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。

我们也可以手动启动垃圾回收，即使用gc.collect()。

分代回收：

1、Python同时采用了分代(generation)回收的策略。这一策略的基本假设是，存活时间越久的对象，越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象，许多对象很快产生和消失，但也有一些对象长期被使用。出于信任和效率，对于这样一些“长寿”对象，我们相信它们的用处，所以减少在垃圾回收中扫描它们的频率。

2、Python将所有的对象分为0，1，2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收，依然存活，那么它就被归入下一代对象。垃圾回收启动时，一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收，那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后，那么会启动对0，1，2，即对所有对象进行扫描。

这两个次数即上面get_threshold()返回的(700, 10, 10)返回的两个10。也就是说，每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收。

3、同样可以用set_threshold()来调整，比如对2代对象进行更频繁的扫描。

import gc

gc.set_threshold(700, 10, 5)

孤立的引用环：

1、引用环的存在会给上面的垃圾回收机制带来很大的困难。这些引用环可能构成无法使用，但引用计数不为0的一些对象。

a = []

b = [a]

a.append(b)

del a

del b

上面我们先创建了两个表对象，并引用对方，构成一个引用环。删除了a，b引用之后，这两个对象不可能再从程序中调用，就没有什么用处了。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收。

2、为了回收这样的引用环，Python复制每个对象的引用计数，可以记为gc_ref。假设，每个对象i，该计数为gc_ref_i。Python会遍历所有的对象i。对于每个对象i引用的对象j，将相应的gc_ref_j减1；在结束遍历后，gc_ref不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留。而其它的对象则被垃圾回收。

总结：

1、Python作为一种动态类型的语言，其对象和引用分离。这与曾经的面向过程语言有很大的区别。为了有效的释放内存，Python内置了垃圾回收的支持。Python采取了一种相对简单的垃圾回收机制，即引用计数，并因此需要解决孤立引用环的问题。

2、Python与其它语言既有共通性，又有特别的地方。对该内存管理机制的理解，是提高Python性能的重要一步。

去期待陌生，去拥抱惊喜。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。