[转] Python内存管理机制

转自:https://www.cnblogs.com/51try-again/p/11099999.html

一、引用计数

1、变量与对象

  • 变量赋值的时候才创建,它可以指向(引用)任何类型的对象

    • python里每一个东西都是对象,它们的核心就是一个结构体:PyObject
  • 变量必须先赋值,再引用。
    • 比如,你定义一个计数器,你必须初始化成0,然后才能自增。
  • 每个对象都包含两个头部字段(类型标识符和引用计数器)

关系图如下:

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

2、共享引用

二、内存优化

1、id()

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

>>> help(id)
Help on built-in function id in module builtins:

id(obj, /)
    Return the identity of an object.

    This is guaranteed to be unique among simultaneously existing objects.
    (CPython uses the object‘s memory address.)

2、引用所指判断

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

整数:

>>> a = 256
>>> b = 256
>>> a is b
True
>>> c = 257
>>> d = 257
>>> c is d
False
>>>

短字符串:

>>> e = "Explicit"
>>> f = "Explicit"
>>> e is f
True
>>>

长字符串:

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

列表:

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

由运行结果可知:

  1、Python缓存整数短字符串,因此每个对象在内存中只存有一份,引用所指对象就是相同的,即使使用赋值

    语句,也只是创造新的引用,而不是对象本身;

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

原理:

# 两种优化机制: 代码块内的缓存机制, 小数据池。

# 代码块
代码全都是基于代码块去运行的(好比校长给一个班发布命令),一个文件就是一个代码块。
不同的文件就是不同的代码块。

# 代码块内的缓存机制
Python在执行同一个代码块的初始化对象的命令时,会检查是否其值是否已经存在,如果存在,会将其重用。
换句话说:执行同一个代码块时,遇到初始化对象的命令时,他会将初始化的这个变量与值存储在一个字典中,
在遇到新的变量时,会先在字典中查询记录,
如果有同样的记录那么它会重复使用这个字典中的之前的这个值。
所以在文件执行时(同一个代码块)会把两个变量指向同一个对象,
满足缓存机制则他们在内存中只存在一个,即:id相同。

注意:
# 机制只是在同一个代码块下!!!,才实行。
# 满足此机制的数据类型:int str bool。

# 小数据池(驻留机制,驻村机制,字符串的驻存机制,字符串的缓存机制等等)
不同代码块之间的优化。
# 适应的数据类型:str bool int
int: -5 ~256
str: 一定条件下的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模块中设置垃圾回收阈值的方法
>>>

3、何为分代回收

  • Python将所有的对象分为0,1,2三代;
  • 所有的新建对象都是0代对象;
  • 当某一代对象经历过垃圾回收,依然存活,就被归入下一代对象。
分代技术是一种典型的以空间换时间的技术,这也正是java里的关键技术。这种思想简单点说就是:对象存在时间越长,越可能不是垃圾,应该越少去收集。
这样的思想,可以减少标记-清除机制所带来的额外操作。分代就是将回收对象分成数个代,每个代就是一个链表(集合),代进行标记-清除的时间与代内对象
存活时间成正比例关系。
从上面代码可以看出python里一共有三代,每个代的threshold值表示该代最多容纳对象的个数。默认情况下,当0代超过700,或1,2代超过10,垃圾回收机制将触发。
0代触发将清理所有三代,1代触发会清理1,2代,2代触发后只会清理自己。

4、标记-清除

标记-清除机制,顾名思义,首先标记对象(垃圾检测),然后清除垃圾(垃圾回收)。
首先初始所有对象标记为白色,并确定根节点对象(这些对象是不会被删除),标记它们为黑色(表示对象有效)。
将有效对象引用的对象标记为灰色(表示对象可达,但它们所引用的对象还没检查),检查完灰色对象引用的对象后,将灰色标记为黑色。
重复直到不存在灰色节点为止。最后白色结点都是需要清除的对象。

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

import gc
import objgraph
import sys
import 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()

答案是:

  1. 弱引用   使用weakref 模块下的 ref 方法
  2. 强制把其中一个引用变成 None

四、内存池机制

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

  1. 大内存使用malloc进行分配
  2. 小内存使用内存池进行分配
  3. Python的内存池(金字塔)

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

  第+1层和第+2层:内存池,有Python的接口函数PyMem_Malloc实现

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

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

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

原文地址:https://www.cnblogs.com/leokale-zz/p/12113108.html

时间: 2024-10-07 12:54:36

[转] Python内存管理机制的相关文章

Python内存管理机制

1 概述 对于Python这样的动态语言,如何高效的管理内存,是很重要的一部分,在很大程度上决定了Python的执行效率.与大多数编程语言不同,Python中的变量无需事先申明,变量无需指定类型,程序员无需关心内存管理,Python解释器给你自动回收.我们知道在变量分配内存时,是借用系统资源,在使用完成后,应该归还所借用的系统资源,Python承担了这个复杂的内存管理工作,从而让程序员更加的关注程序的编写质量上. 在执行过程中,Python会频繁的创建和销毁大量的对象,这些都涉及到内存的管理.以

(重点)Python深入之Python内存管理机制你会吗?

前言本文的文字及图片来源于网络,仅供学习.交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理.作者:醍醐三叶 请注意:如果你平时学Python遇到问题找不到人解答?或者没有较全面的教程?可以点我进裙里面都有,自行去拿! 关于python的存储问题 (1)由于python中万物皆对象,所以python的存储问题是对象的存储问题,并且对于每个对象,python会分配一块内存空间去存储它 (2)对于整数和短小的字符等,python会执行缓存机制,即将这些对象进行缓存,不会为

《python源码剖析》笔记 pythonm内存管理机制

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.内存管理架构 Python的内存管理机制都有两套实现:debug模式和release模式 Python内存管理机制的层次结构: 图16-1 第0层是操作系统提供的内存管理接口,如malloc.free 第1层是Python基于第0层操作系统的内存管理接口包装而成的,主要是为了处理与平台相关的内存分配行为. 实现是一组以PyMem_为前缀的函数族 两套接口:函数和宏. 宏,可以避免函数调

深入详解python传值问题及内存管理机制

在比较浅层次上我们通过说明如下问题来进一步深入了解python内存管理机制: python中到底是"传引用"还是"传值"呢??? 这个问题的回答是:看情况.有的是传值,有的是传引用. 判断的依据是看对象的可变性,而这一点又取决于对象的类型.故在python中的说法是对象可变的还是不可变的. 基本数据类型(整型及其他数据类型,字符串)及元组是不可变的,参数传递的是形参,也就是传过来的是原值的一个拷贝,在函数中改变形参的值实参不会发生变化: def func(a) 列表

转发:[Python]内存管理

本文为转发,原地址为:http://chenrudan.github.io/blog/2016/04/23/pythonmemorycontrol.html 本文主要为了解释清楚python的内存管理机制,首先介绍了一下python关于内存使用的一些基本概念,然后介绍了引用计数和垃圾回收gc模块,并且解释了分代回收和"标记-清除"法,然后分析了一下各种操作会导致python变量和对象的变化,最后做了一下小结.本来是为了解决前几天遇到把服务器内存耗光的问题,结果后来检查发现并不是因为内存

[转载] python的内存管理机制

本文为转载,原作为http://www.cnblogs.com/CBDoctor/p/3781078.html,请大家支持原作者 先从较浅的层面来说,Python的内存管理机制可以从三个方面来讲 (1)垃圾回收 (2)引用计数 (3)内存池机制 一.垃圾回收: python不像C++,Java等语言一样,他们可以不用事先声明变量类型而直接对变量进行赋值.对Python语言来讲,对象的类型和内存都是在运行时确定的.这也是为什么我们称Python语言为动态类型的原因(这里我们把动态类型可以简单的归结

python的内存管理机制

先从较浅的层面来说,Python的内存管理机制可以从三个方面来讲 (1)垃圾回收 (2)引用计数 (3)内存池机制 一.垃圾回收: python不像C++,Java等语言一样,他们可以不用事先声明变量类型而直接对变量进行赋值.对Python语言来讲,对象的类型和内存都是在运行时确定的.这也是为什么我们称Python语言为动态类型的原因(这里我们把动态类型可以简单的归结为对变量内存地址的分配是在运行时自动判断变量类型并对变量进行赋值). 二.引用计数: Python采用了类似Windows内核对象

python的内存管理机制(zz)

本文转载自:http://www.cnblogs.com/CBDoctor/p/3781078.html 先从较浅的层面来说,Python的内存管理机制可以从三个方面来讲 (1)垃圾回收 (2)引用计数 (3)内存池机制 一.垃圾回收: python不像C++,Java等语言一样,他们可以不用事先声明变量类型而直接对变量进行赋值.对Python语言来讲,对象的类型和内存都是在运行时确定的.这也是为什么我们称Python语言为动态类型的原因(这里我们把动态类型可以简单的归结为对变量内存地址的分配是

【python】python值传递问题和内存管理机制

1)值传递问题 python中到底是"值传递"还是"引用传递",主要取决于对象是否是可变的.     1)函数传参:    ·基本数据类型:int.float.str:元祖属于不可变对象:传递的是"原值"的拷贝    ·列表.字典.类.类实例属于可变对象:传递的是"值引用"          2)变量复制    ·python中的变量复制(a=b)也是同样的道理,不可变对象被真正复制:而可变对象只是传递了一个     &quo