Python 内存管理学习

Python中的所有东西都是对象。这意味着动态内存分配是Python内存管理的基础。当不再需要对象时，Python内存管理器将自动从它们中回收内存。

Python是使用C编程语言实现的高级编程语言。Python内存管理器管理Python的内存分配。有一个私有heap，其中包含所有Python对象和数据结构。Python内存管理器按需管理Python堆。Python内存管理器具有特定于对象的分配器，可为int，string等特定对象分别分配内存。在此之下，原始内存分配器与操作系统的内存管理器进行交互，以确保私有堆上有空间。

python 中的内存管理涉及包含所有 python 对象和数据结构的私有堆。 python 内存管理器在内部保证这个私有堆的管理。 python 内存管理器有不同的组件，这些组件处理各种动态存储管理方面，比如共享，分割，预分配或者缓存。

Python内存管理器管理称为“块”的内存块。相同大小的块的集合构成了“池”。池是在Arenas上创建的，在堆= 64池上分配了256kB的内存块。如果对象被销毁，则内存管理器将用相同大小的新对象填充此空间。

方法和变量在堆栈存储器中创建。每当创建方法和变量时，都会创建一个堆栈框架。只要返回方法，这些框架就会自动销毁。

在堆内存中创建对象和实例变量。一旦返回变量和函数，将对垃圾对象进行垃圾回收。

请务必注意，Python内存管理器不一定会将内存释放回操作系统，而是将内存返回给python解释器。Python有一个小的对象分配器，用于分配内存以供进一步使用。在长时间运行的进程中，您可能有未使用内存的增量保留。

Python 的内存管理主要有三种机制：引用计数机制，垃圾回收机制和内存池机制。

引用计数机制

对象的内存

赋值语句是语言最常见的功能了。但即使是最简单的赋值语句，也可以很有内涵。Python的赋值语句就很值得研究。

a = 1

整数1为一个对象。而a是一个引用。利用赋值语句，引用a指向对象1。

为了探索对象在内存的存储，我们可以求助于Python的内置函数id()。它用于返回对象的身份(identity)。其实，这里所谓的身份，就是该对象的内存地址。

a = 1

print(id(a))

print(hex(id(a)))

它们返回的是:
1914562480
0x721de7b0
分别为内存地址的十进制和十六进制表示。

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

a = 1

b = 1

print(id(a))

print(id(b))

1914562480
1914562480
可见a和b实际上是指向同一个对象的两个引用。

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

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

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

from sys import getrefcount

a = [1, 2, 3]

print(getrefcount(a))

b = a

print(getrefcount(b))

由于上述原因，两个getrefcount将返回2和3，而不是期望的1和2。

对象引用

Python的一个容器对象(container)，比如表、词典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。
容器对象的引用可能构成很复杂的拓扑结构。我们可以用objgraph包来绘制其引用关系，比如:

x = [1, 2, 3]

y = [x, dict(key1=x)]

z = [y, (x, y)]

import objgraph

objgraph.show_refs([z], filename='show_refs.png')

两个对象可能相互引用，从而构成所谓的引用环(reference cycle)。

a = []

b = [a]

a.append(b)

即使是一个对象，只需要自己引用自己，也能构成引用环。

a = []

a.append(a)

print(getrefcount(a))

垃圾回收机制

当Python中的对象越来越多，它们将占据越来越大的内存。不过不用太担心Python的体形，它会乖巧的在适当的时候启动垃圾回收(garbage collection)，将没用的对象清除。

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

a = [1, 2, 3]

del a

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

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

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

import gc

print(gc.get_threshold())

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

循环引用的回收策略

上文已经举例说明循环引用计数的问题，出现循环引用后，利用上述引用计数机制无法对循环引用中的对象进行释放空间，这就是循环引用问题。 解决循环引用并释放内存（标记清除）：

• 收集所有容器对象（循环引用只针对于容器对象，其他对象不会产生循环引用），使用双向链表（可以看作一个集合）对这些对象进行引用；

• 针对每一个容器对象，使用变量gc_refs来记录当前对应的应用个数；

• 对于每个容器对象，找到其正在引用的其他容器对象，并将这个被引用的容器对象引用计数减去1；

• 检查所有容器对象的引用计数，若为0，则证明该容器对象是由于循环引用存活下来的，并对其进行销毁。

如何提升查找循环引用过程的性能?

由一可知，循环引用查找和销毁过程非常繁琐，要分别处理每一个容器对象，所以python考虑一种改善性能的做法，即分代回收。 首先是一个假设–如果一个对象被检测了10次还没有被销毁，就减少对其的检测频率；基于这个假设，提出一套机制，即分代回收机制。 分代回收是建立在标记清除技术基础之上的，是一种以空间换时间的操作方式。

Python将内存根据对象的存活时间划分为不同的集合，每个集合称为一个代，Python将内存分为了3“代”，分别为年轻代（第0代）、中年代（第1代）、老年代（第2代），他们对应的是3个链表，它们的垃圾收集频率与对象的存活时间的增大而减小。新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推，老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。

内存分配（内存池机制）

Python频繁地创建和销毁一些小的对象，为了减少小对象（小于512字节）的开销，Python引入了内存池机制, 用于管理对小块内存的申请和释放，较大的对象被路由到标准C分配器。 我们可以在obmalloc.c源码中可以看到关于小内存请求的描述

分配的内存空间大于 SMALL_REQUEST_THRESHOLD 将直接使用layer 1的内存分配接口进行分配。 pymalloc 把“内存池”主要抽象成用3种数据结构表示：block、pool、arena

block

块指的是一个确定大小的内存块，每个块保留一个固定大小的Python对象，块的大小可以从8到512字节，并且是8的倍数（即8字节对齐）。

block由pool管理，所有512字节以下的内存申请会根据申请字节的大小分配不一样的block，一个pool通常为4K（系统页大小），一个pool管理着一堆固定大小的内存块（block） obmalloc.c源代码注释：

* Request in bytes                           Size of allocated block      Size class idx

 * ----------------------------------------------------------------

 *        1-8                    8                       0

 *        9-16                   16                       1

 *       17-24                   24                       2

 *       25-32                   32                       3

 *       33-40                   40                       4

 *       41-48                   48                       5

 *       49-56                   56                       6

 *       57-64                   64                       7

 *       65-72                   72                       8

 *        ...                   ...                     ...

 *      497-504                 504                      62

 *      505-512                 512                      63

Pool

pool 由若干个大小相等的 block 组成，相同大小的块集合称为池。通常池的大小等于存储器页面的大小，即4Kb。 将池限制为固定大小的块有助于碎片化管理，如果对象被破坏，则内存管理器可以使用相同大小的新对象填充此空间。

/* Pool for small blocks. */

struct pool_header {

    union { block *_padding;

            uint count; } ref;          /* number of allocated blocks    */

    block *freeblock;                   /* pool's free list head         */

    struct pool_header *nextpool;       /* next pool of this size class  */

    struct pool_header *prevpool;       /* previous pool       ""        */

    uint arenaindex;                    /* index into arenas of base adr */

    uint szidx;                         /* block size class index        */

    uint nextoffset;                    /* bytes to virgin block         */

    uint maxnextoffset;                 /* largest valid nextoffset      */

};

每个池都使用双向链表（nextpool和prevpool字段）将相同大小的块的池链接在一起。通过这种方式，即使跨不同的池，算法也可以轻松找到给定块大小的可用空间。 szidx字段保存size类索引，而ref.count保留已使用块的数量。 arenaindex存储创建Pool的arena的索引。

每个Pool有三种状态： - used - 具有可用于存储数据的块，部分使用，既不空也不满 - full - 所有池的块目前都已分配并包含数据，当该 pool 上的一个 block 被回收时，重新将该 pool 链接在适当的 usedpools 链表中。 - empty - 没有存储数据，可以在需要时分配

我们已经知道，所有相同块大小的池都链接在一起。为了有效地管理池，Python使用了一个名为usedpools的列表存储跟踪可用池的指针。在分配内存时，Pymalloc先判断是否存在要申请的大小的Pool，如果存在的话，直接从Pool中获取一个Free Block返回给应用程序，这个过程是非常迅速的。如果分配完这个Block后此Pool变为一个空Pool，则将这个Pool从链表中移除。

Arena

Arenas是最大的内存块，并在内存中的页面边界上对齐，页面边界是OS使用的固定长度连续内存块的边缘。在Arena内的池是一个虚拟内存页（4K），在堆上分配的256kB内存块，为64个池提供内存。

arena 结构定义如下obmalloc.c：

struct arena_object {

    uintptr_t address;

    block* pool_address;

    uint nfreepools;

    uint ntotalpools;

    struct pool_header* freepools;

    struct arena_object* nextarena;

    struct arena_object* prevarena;

};

所有arena都使用双链表（nextarena和prevarena字段）链接，跟上面的pool类似。 ntotalpools 总共分配的 pool 数量 nfreepools 可分配的 pool 数量 freepools 字段指向可用池的链接列表

Arenas的实现没有什么复杂的。可以将其视为容器列表，在需要时自动为Pool分配新内存。

Python的小对象管理器不一定会将内存释放回操作系统，保留了一些已分配的内存块，以备将来进一步使用。 arena 完全释放当且仅当其中的所有池都为空时，如果长时间运行的Python进程随着时间的推移需要更多内存，但并不一定意味着您有内存泄漏。

内存优化

内存分析工具

资源（resource）

resource 模块用来查看项目当前得的固有的)内存消耗(固有内存是项目实际使用的RAM)，注意resource库只在linux系统下有效

import resource

resource.getrusage(resource.RUSAGE_SELF).ru_maxrss

443

对象（objgraph）

objgraph 是一个实用模块，可以展示当前内存中存在的对象，上文中已经展示过其用法，不再过多说明。

Heapy

heapy 是一个实用的，用于调试内存消耗/泄漏的工具。通常，我将objgraph和heapy搭配使用：用 heapy 查看分配对象随时间增长的差异，heapy能够显示对象持有的最大内存等；用Objgraph找backref链，尝试获取它们不能被释放的原因。

Heapy的典型用法是在不同地方的代码中调用一个函数，试图为内存使用量提供大量收集线索，找到可能会引发的问题：

from guppyimport hpy

def dump_heap(h, i):

    """

    @param h: Theheap (from hp = hpy(), h = hp.heap())

    @param i: Identifierstr

    """

    print "Dumpingstatsat: {0}".format(i)

    print 'Memoryusage: {0}(MB)'.format(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024)

    print "Mostcommontypes:"

    objgraph.show_most_common_types()

    print "heapis:"

    print "{0}".format(h)

    by_refs = h.byrcs

    print "byreferences: {0}".format(by_refs)

    print "Morestatsfor topelement.."

    print "Byclodo (class or dict owner): {0}".format(by_refs[0].byclodo)

    print "Bysize: {0}".format(by_refs[0].bysize)

    print "Byid: {0}".format(by_refs[0].byid)

内存用量诊断工具（memory_profiler）

memory_profile包最好有psutil包的支持，二者皆可以通过pip安装。

pip install psutil memory_profiler

memory_profiler的对性能的影响很大，所以最好将测试局限在一个较小的问题上，或者在代码成长的早期进行分析。

使用的方法分两步:
第一步是在源代码中用‘@profile’对需要分析的函数进行标记，
第二步是调用memory_profiler模块进行分析。

python -m memory_profiler test_memory.py

在处理内存分配时，情况并不像CPU占有率那么直截了当，通常一个进程将内存超额分配给本地内存池并在空闲时使用会更有效率，因为一次内存分配的操作非常昂贵；
另外，垃圾收集不会立即执行，所以对象被销毁后依然会存在垃圾收集池中一段时间；
这些技术的后或是很难真正了解一个Python程序内部的内存使用和释放情况，因为当从进程外部观察时，某一段代码可能不会分配固定数量的内存，观察多行代码的内存占有趋势可能比只观察一行代码更有参考价值。

垃圾回收优化

手动垃圾回收

对Python的垃圾回收进行调优的一个最简单的手段便是关闭自动回收，根据情况手动触发。

调高垃圾回收阈值

相比完全手动的垃圾回收，一个更温和的方法是调高垃圾回收的阈值。 调高阈值的方法能在一定程度上避免内存溢出的问题(但不能完全避免)，同时可能减少可观的垃圾回收开销。根据具体项目 的不同，甚至是程序输入的不，合适的阈值也不同。因此需要反复测试找到一个合适的阈值，这也算调高阈值这种手段 的一个缺点。

避免循环引用

一个可能更好的方法是使用良好的编程习惯尽可能的避免循环引用。两种常见的手段包括: 手动解循环引用和使用弱引用。

查找循环引用， Python的gc模块提供了gc.set_debug接口来设置一些辅助的调试信息。如果我们调用gc.set_debug(gc.DEBUG_COLLECTABLE | gc.DEBUG_OBJECTS)则每当Python进行垃圾回收时都会将 其发现的无法到达需要回收的对象的信息打印出来。例如：

gc.collect()

gc.set_debug(gc.DEBUG_COLLECTABLE | gc.DEBUG_OBJECTS)

test2()

gc.collect()

gc: collectable <T 0x7fb6cacf6090>

gc: collectable <T 0x7fb6cace0fd0>

gc: collectable <dict 0x7fb6cac974b0>

gc: collectable <dict 0x7fb6cac97280>

Slots

默认情况下，自定义的对象都使用dict来存储属性（通过obj.dict__查看），而python中的dict大小一般比实际存储的元素个数要大（以此降低hash冲突概率），因此会浪费一定的空间。在新式类中使用__slots，就是告诉Python虚拟机，这种类型的对象只会用到这些属性，因此虚拟机预留足够的空间就行了，如果声明了__slots__，那么对象就不会再有__dict__属性。

class Student(object):

    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

使用slots到底能带来多少内存优化呢，取决于类自身有多少属性、属性的类型，以及同时存在多少个类的实例。

# -*- coding: utf-8 -*-

import sys

import tracemalloc

NUM_OF_ATTR =  3 #3 # 10 # 30 #90

NUM_OF_INSTANCE = 10 # 10 # 100

class Slots(object):

    __slots__ = ['attr%s'%i for i in range(NUM_OF_ATTR)]

    def __init__(self):

        value_lst = (1.0, True, [], {}, ())

        for i in range(NUM_OF_ATTR):

            setattr(self, 'attr%s'%i, value_lst[i % len(value_lst)])

class NoSlots(object):

    def __init__(self):

        value_lst = (1.0, True, [], {}, ())

        for i in range(NUM_OF_ATTR):

            setattr(self, 'attr%s'%i, value_lst[i % len(value_lst)])

if __name__ == '__main__':

    clz = Slots if len(sys.argv) > 1 else NoSlots

    tracemalloc.start()

    objs = [clz() for i in range(NUM_OF_INSTANCE)]

    print(tracemalloc.get_traced_memory()[0])

上面的代码，主要是在每个实例的属性数目、并发存在的实例数目两个维度进行测试，并没有测试不同的属性类型。结果如下表：

百分比为内存优化百分比，计算公式为(b - a) / b， 其中b为没有使用__slots__时分配的内存， a为使用了__slots__时分配的内存。

注意事项

·         基类和子类都必须__slots__，即使基类或者子类没有属性

·         >>> class Base(object):

·

·         ...     pass

·         ...

·         >>> class Derived(Base):

·         ...     __slots__ = ('a', )

·         ...

·         >>> d.__slots__

·         ('a',)

·         >>> getattr(d, '__dict__', 'No Dict')

·         {}

·         子类会继承基类的__slots__

·         >>> class Base(object):

·

·         ...     __slots__ = ('a',)

·         ...

·         >>> class Derived(Base):

·         ...     __slots__ = ('b', )

·         ...

·         >>> d = Derived()

·         >>> d.__slots__

·         ('b',)

·         >>> getattr(d, '__dict__', 'No Dict')

·         'No Dict'

·         >>> d.a = 1

·         >>> d.c = 0

·         Traceback (most recent call last):

·           File "<stdin>", line 1, in <module>

·         AttributeError: 'Derived' object has no attribute 'c'

栈溢出

在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

尾递归

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

例如斐波那契数列，在最开始的时候所有的斐波那契代码都是使用递归的方式来写的，递归有很多的缺点，执行效率低下，浪费资源，还有可能会造成栈溢出，而递归的程序的优点也是很明显的，就是结构层次很清晰，易于理解。

可以使用循环的方式来取代递归，当然也可以使用尾递归的方式来实现。

#encoding:utf-8

import time

def Fib_recursion(num):

    '''

    直接使用递归法求解斐波那契数量的第num个数字

    '''

    if num<2:

        return num

    return Fib_recursion(num-1)+Fib_recursion(num-2)

def Fib_tail_recursion(num,res,temp):

    '''

    使用尾递归法求解斐波那契数量的第num个数字

    '''

    if num==0:

        return res

    else:

        return Fib_tail_recursion(num-1, temp, res+temp)

def Fib_circle(num):

    '''

    直接使用循环来求解

    '''

    a=0

    b=1

    for i in range(1,num):

        c=a+b

        a=b

        b=c

    return c

if __name__ == '__main__':

    num_list=[5,10,20,30,40,50]

    for num in num_list:

        start_time=time.time()

        print Fib_recursion(num)

        end_time=time.time()

        print Fib_tail_recursion(num,0,1)

        end_time2=time.time()

        print Fib_circle(num)

        end_time3=time.time()

        print '正在求解的斐波那契数字下标为%s' %num

        print '直接递归耗时为 ：', end_time-start_time

        print '尾递归调用耗时为：', end_time2-end_time

        print '直接使用循环耗时为：', end_time3-end_time2

deepcopy

copy模块的deepcopy可以很好的完成对象的深拷贝，一个深层拷贝会构造一个新的复合对象，然后递归地将原始对象中所找到的对象的副本 插入。

• 当对象节点内容过于庞大或者存在循环应用的话，会导致栈内存溢出或者递归循环导致进程崩溃；

• 实际中，由于深层复制会复制所有内容，因此可能会过多复制（例如本应该在副本之间共享的数据）。