跳到主要内容

Python 的内存管理与垃圾回收

1. 内存管理概述​

1.1 手动内存管理​

在计算机发展的早期，编程语言提供了手动内存管理的机制，例如 C 语言，提供了用于分配和释放的函数 malloc 和 free，如下所示：

#include <stdlib.h>

void \*malloc(size_t size);
void free(void \*p);

  • 函数 malloc 分配指定大小 size 的内存，返回内存的首地址
  • 函数 free 释放之前申请的内存

程序员负责保证内存管理的正确性：使用 malloc 申请一块内存后，如果不再使用，需要使用 free 将其释放，示例如下：

#include <stdlib.h>

void test()
{
    void \*p = malloc(10);

    访问 p 指向的内存区域;

    free(p);
}

int main()
{
    test();
}

  • 使用 malloc(10) 分配一块大小为 10 个字节的内存区域
  • 使用 free§ 释放这块内存区域

如果忘记释放之前使用 malloc 申请的内存，则会导致可用内存不断减少，这种现象被称为 “内存泄漏”，示例如下：

#include <stdio.h>
#include <stdlib.h>

void test()
{
    void \*p = malloc(10);

    访问 p 指向的内存区域;
}

int main()
{
    while (1)
        test();
}

  • 在函数 test 中，使用 malloc 申请一块内存
    • 但是使用完毕后，忘记释放了这块内存
  • 在函数 main 中，循环调用函数 test()
    • 每次调用函数 test()，都会造成内存泄漏
    • 最终，会耗尽所有的内存

1.2 自动内存管理​

在计算机发展的早期，硬件性能很差，为了最大程度的压榨硬件性能，编程语言提供了手动管理内存的机制。手动管理内存的机制的优点在于能够有效规划和利用内存，其缺点在于太繁琐了，很容易出错。

随着计算机的发展，硬件性能不断提高，这时候出现的编程语言，例如：Java、C#、PHP、Python，则提供了自动管理内存的机制：程序员申请内存后，不需要再显式的释放内存，由编程语言的解释器负责释放内存，从根本上杜绝了 “内存泄漏” 这类错误。

在下面的 Python 程序中，在无限循环中不断的申请内存:

class Person:
    def \_\_init\_\_(self, name, age):
        self.name = name
        self.age = age

while True:
    person = Person('tom', 13)

  • 类 Person 包含两个属性：name 和 age
  • 在 while 循环中，使用类 Person 生成一个实例 person
    • 需要申请一块内存用于保存实例 person 的属性

Python 解释器运行这个程序时，发现实例 person 不再被引用后，会自动的释放 person 占用的空间。因此这个程序可以永远的运行下去，而不会把内存耗尽。

2. 基于引用计数的内存管理​

2.1 基本原理​

引用计数是一种最简单的自动内存管理机制：

  • 每个对象都有一个引用计数
  • 当把该对象赋值给一个变量时，对象的引用计数递增 1

引用计数的实例如下：

A = object()
B = A
A = None
B = None

  • 在第 1 行，使用 object() 创建一个对象，变量 A 指向该对象
    • 对象的引用计数变化为 1
  • 在第 2 行，变量 B 指向相同的对象
    • 对象的引用计数变化为 2
  • 在第 3 行，变量 A 指向 None
    • 对象的引用计数变化为 1
  • 在第 3 行，变量 B 指向 None
    • 对象的引用计数变化为 0

引用计数

从图中可以看出，当变量 A 和变量 B 都不再指向对象时，对象的引用计数变为 0，系统检测到该对象成为废弃对象，可以将此废弃对象回收。

2.2 优点和缺点​

引用计数的优点在于：

  • 实现简单
  • 系统检测到对象的引用计数变为 0 后，可以及时的释放废弃的对象
  • 处理回收内存的时间分摊到了平时

引用计数的缺点在于：

  • 维护引用计数消耗性能，每次变量赋值时，都需要维护维护引用计数
  • 无法释放存在循环引用的对象

下面是一个存在循环引用的例子：

class Node:
    def \_\_init\_\_(self, data, next):
        self.data = data
        self.next = next

node = Node(123, None)
node.next = node
node = None

  • 在第 6 行，创建对象 node
    • 对象 node 的 next 指向 None
    • 此时对象 node 的引用计数为 1
  • 在第 7 行，对象 node 的 next 指向 node 自身
    • 此时对象 node 的引用计数为 2
  • 在第 7 行，对象 node 指向 None
    • 此时对象 node 的引用计数为 1

对象 node 的 next 字段指向自身，导致：即使没有外部的变量指向对象 node，对象 node 的引用计数也不会变为 0，因此对象 node 就永远不会被释放了。

3. 基于垃圾回收的内存管理​

3.1 基本原理​

垃圾回收是目前主流的内存管理机制：

  • 通过一系列的称为 “GC Root” 的对象作为起始对象
  • 从 GC Root 出发，进行遍历
  • 最终将对象划分为两类：
    • 从 GC Root 可以到达的对象
    • 从 GC Root 无法到达的对象

从 GC Root 无法到达的对象被认为是废弃对象，可以被系统回收。

垃圾回收

  • 在 Python 语言中，可作为 GC Roots 的对象主要是指全局变量指向的对象。
  • 从 GC Roots 出发，可以到达 object 1、object 2、object 3、object 4
  • 从 GC Roots 出发，无法到达 object 5、object 6、object 7，它们被判定为可回收的对象

3.2 优点和缺点​

垃圾回收的优点在于：

  • 可以处理存在循环引用的对象

垃圾回收的缺点在于：

  • 实现复杂
  • 进行垃圾回收时，需要扫描程序中所有的对象，因此需要暂停程序的运行。当程序中对象数量较多时，暂停程序的运行时间过长，系统会有明显的卡顿现象。

4. Python 的内存管理机制​

Python 的内存管理采用了混合的方法：

  • Python 使用引用计数来保持追踪内存中的对象，当对象的引用计数为 0 时，回收该对象
  • Python 同时使用垃圾回收机制来回收存在有循环引用的对象

下面的例子中，演示了 Python 的内存管理策略：

class Circular:
    def \_\_init\_\_(self):
        self.data = 0
        self.next = self

class NonCircular:
    def \_\_init\_\_(self):
        self.data = 0
        self.next = None

def hybrid():
    while True:
        circular = Circular()
        nonCircular = NonCircular()

hybrid()

  • 类 Circular，创建了一个包含循环引用的对象
    • self.next 指向自身，导致了循环引用
    • 类 Circular 的实例只能被垃圾回收机制释放
  • 类 NonCircular，创建了一个不包含循环引用的对象
    • self.next 指向 None，没有循环引用
    • 类 NonCircular 的实例可以引用计数机制释放
  • 在方法 hybrid 中
    • 在无限循环中，不断的申请 Circular 实例和 NonCircular 实例

通过引用计数和垃圾回收机制，内存不会被耗尽，程序可以永远的运行下去。