Python中的内存管理机制

2020-06-28 16:30 Python编程笔记

Python的内存管理机制:引入计数、垃圾回收、内存池机制


一、引入计数


1、变量与对象


  • 变量赋值的时候才创建,它可以指向(引用)任何类型的对象
    python里每一个东西都是对象,它们的核心就是一个结构体:PyObject

  • 变量必须先赋值,再引用。
    比如,你定义一个计数器,你必须初始化成0,然后才能自增。

  • 每个对象都包含两个头部字段(类型标识符和引用计数器)
    关系图如下:


变量名没有类型,类型属于对象(因为变量引用对象,所以类型随对象),在Python中,变量是一种特定类型对象在一个特定的时间点的引用。


2、共享引用


1、id() 是 python 的内置函数,用于返回对象的标识,即对象的内存地址。


2、引用所指判断


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


整数

>>> a = 256>>> b = 256>>> a is bTrue>>> c = 257>>> d = 257>>> c is dFalse>>>


短字符串

>>> e = "Explicit">>> f = "Explicit">>> e is fTrue>>>


长字符串

>>> g = "Beautiful is better">>> h = "Beautiful is better">>> g is hFalse>>>


列表

>>> lst1 = [1, 2, 3]>>> lst2 = [1, 2, 3]>>> lst1 is lst2False>>>


由运行结果可知:


1、Python缓存了整数和短字符串,因此每个对象在内存中只存有一份,引用所指对象就是相同的,即使使用赋值语句,也只是创造新的引用,而不是对象本身;


2、Python没有缓存长字符串、列表及其他对象,可以由多个相同的对象,可以使用赋值语句创建出新的对象。


原理:

# 两种优化机制:代码块内的缓存机制, 小数据池。
# 代码块代码全都是基于代码块去运行的(好比校长给一个班发布命令),一个文件就是一个代码块。不同的文件就是不同的代码块。
# 代码块内的缓存机制Python在执行同一个代码块的初始化对象的命令时,会检查是否其值是否已经存在,如果存在,会将其重用。换句话说:执行同一个代码块时,遇到初始化对象的命令时,他会将初始化的这个变量与值存储在一个字典中,在遇到新的变量时,会先在字典中查询记录,如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在文件执行时(同一个代码块)会把两个变量指向同一个对象,满足缓存机制则他们在内存中只存在一个,即:id相同。
注意:# 机制只是在同一个代码块下!!!,才实行。# 满足此机制的数据类型:int str bool。

# 小数据池(驻留机制,驻村机制,字符串的驻存机制,字符串的缓存机制等等)不同代码块之间的优化。# 适应的数据类型:str bool intint:-5 ~256str: 一定条件下的str满足小数据池。bool值 全部。

# 总结:如果你在同一个代码块中,用同一个代码块中的缓存机制。如果你在不同代码块中,用小数据池。
# 优点:1,节省内存。2,提升性能。


3、查看对象的引用计数

在Python中,每个对象都有指向该对象的引用总数 --- 引用计数】


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


当对变量重新赋值时,它原来引用的值去哪啦?比如下面的例子,给 s 重新赋值 字符串 apple,6 跑哪里去啦?

>>> s = 6>>> s = 'apple'


答案是:当变量重新赋值时,它原来指向的对象(如果没有被其他变量或对象引用的话)的空间可能被收回(垃圾回收)


普通引用

>>> import sys>>>>>> a = "simple">>> sys.getrefcount(a)2>>> b = a>>> sys.getrefcount(a)3>>> sys.getrefcount(b)3>>>


注意:当使用某个引用作为参数,传递给getrefcount()时,参数实际上创建了一个临时的引用。因此,getrefcount()所得到的结果,会比期望的多1。


三、垃圾回收


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


1、原理


当Python的某个对象的引用计数降为0时,说明没有任何引用指向该对象,该对象就成为要被回收的垃圾。


比如某个新建对象,被分配给某个引用,对象的引用计数变为1。如果引用被删除,对象的引用计数为0,那么该对象就可以被垃圾回收。


2、解析del


del 可以使 对象的引用计数减 1,该表引用计数变为0,用户不可能通过任何方式接触或者动用这个对象,当垃圾回收启动时,Python扫描到这个引用计数为0的对象,就将它所占据的内存清空。


注意

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

  • 2、Python只会在特定条件下,自动启动垃圾回收(垃圾对象少就没必要回收)

  • 3、当Python运行时,会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。


当两者的差值高于某个阈值时,垃圾回收才会启动。

>>> import gc>>>>>> gc.get_threshold() #gc模块中查看垃圾回收阈值的方法(700, 10, 10)>>>


阈值分析:


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


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


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

>>> gc.collect()       #手动启动垃圾回收52>>> gc.set_threshold(666, 8, 9) # gc模块中设置垃圾回收阈值的方法>>>


何为分代回收


  • Python将所有的对象分为0,1,2三代;

  • 所有的新建对象都是0代对象;

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


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


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


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


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


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


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


将有效对象引用的对象标记为灰色(表示对象可达,但它们所引用的对象还没检查),检查完灰色对象引用的对象后,将灰色标记为黑色。关注公众号Python编程笔记,回复关键字手册,获取最新开发手册


重复直到不存在灰色节点为止。最后白色结点都是需要清除的对象。


如何解决循环引用可能导致的内存泄露问题呢?


答案是:


  • 弱引用   使用weakref 模块下的 ref 方法

  • 强制把其中一个引用变成 None

import gcimport objgraphimport sysimport weakref

def quote_demo(): class Person: pass
p = Person() # 1 print(sys.getrefcount(p)) # 2 first
def log(obj): # 4 second 函数执行才计数,执行完释放 print(sys.getrefcount(obj))
log(p) # 3
p2 = p # 2 print(sys.getrefcount(p)) # 3 del p2 print(sys.getrefcount(p)) # 3 - 1 = 2

def circle_quote(): # 循环引用 class Dog: pass
class Person: pass
p = Person() d = Dog()
print(objgraph.count("Person")) print(objgraph.count("Dog"))
p.pet = d d.master = p
# 删除 p, d之后, 对应的对象是否被释放掉 del p del d
print(objgraph.count("Person")) print(objgraph.count("Dog"))

def solve_cirecle_quote(): # 1. 定义了两个类 class Person: def __del__(self): print("Person对象, 被释放了")
pass
class Dog: def __del__(self): print("Dog对象, 被释放了")
pass
p = Person() d = Dog()
p.pet = d d.master = p
p.pet = None # 强制置 None del p del d
gc.collect()
print(objgraph.count("Person")) print(objgraph.count("Dog"))

def sovle_circle_quote_with_weak_ref(): # 1. 定义了两个类 class Person: def __del__(self): print("Person对象, 被释放了")
pass
class Dog: def __del__(self): print("Dog对象, 被释放了")
pass
p = Person() d = Dog()
p.pet = d d.master = weakref.ref(p)
del p del d
gc.collect()
print(objgraph.count("Person")) print(objgraph.count("Dog"))

if __name__ == "__main__": quote_demo() circle_quote() solve_cirecle_quote() sovle_circle_quote_with_weak_ref()


四、内存池机制


Python中有分为大内存和小内存:(256K为界限分大小内存)


  • 大内存使用malloc进行分配

  • 小内存使用内存池进行分配


Python的内存池(金字塔)


  • 第+3层:最上层,用户对Python对象的直接操作

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

  • 第0层:大内存  -----> 若请求分配的内存大于256K,malloc函数分配内存,free函数释放内存。

  • 第-1,-2层:操作系统进行操作

作者:51try-again

来源:lhttps://www.cnblogs.com/51try-again/p/11099999.html


往期推荐 

🔗



让我知道你在看

本文章转载自公众号:pynotebook

首页 - Python 相关的更多文章: