python 内存管理机制

想胖的壮壮2024-06-20 16:22

1. 内存分配

栈内存（Stack Memory）

栈内存用于存储函数调用过程中创建的局部变量。当函数调用结束时，这些局部变量会被自动销毁。

例子：

python 复制代码 
def func():
    a = 10  # 'a' 分配在栈内存上
    b = 20  # 'b' 也分配在栈内存上
    return a + b

result = func()
# 当 func() 调用结束后，变量 'a' 和 'b' 的内存会被自动释放
堆内存（Heap Memory）

堆内存用于动态分配内存，对象和数据结构通常存储在堆内存中。这些对象的内存不会自动释放，需要垃圾收集器来管理。

例子：

python 复制代码 
class Node:
    def __init__(self, value):
        self.value = value  # 'value' 存储在堆内存中
        self.next = None    # 'next' 存储在堆内存中

head = Node(1)
head.next = Node(2)
# 'head' 和 'head.next' 的内存分配在堆上，由垃圾收集器管理

2. 引用计数

每个 Python 对象都有一个引用计数，当引用计数为零时，对象的内存会被释放。

例子：

python 复制代码 
import sys

a = []  # 创建一个空列表对象，引用计数为 1
print(sys.getrefcount(a))  # 输出引用计数，应该是 2（包括传递给 getrefcount 的参数引用）

b = a   # 现在 'a' 和 'b' 都引用同一个列表对象，引用计数增加到 2
print(sys.getrefcount(a))  # 输出引用计数，应该是 3

del a   # 删除 'a' 的引用，引用计数减少到 2
print(sys.getrefcount(b))  # 输出引用计数，应该是 2

del b   # 删除 'b' 的引用，引用计数减少到 1
# 当引用计数降为 0 时，列表对象的内存会被释放

3. 垃圾收集（GC）

Python 的垃圾收集器用来处理循环引用的情况，即两个或多个对象互相引用，导致引用计数永远不会归零。

例子：

python 复制代码 
import gc

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

def create_cycle():
    a = Node(1)
    b = Node(2)
    a.next = b
    b.next = a  # 创建循环引用
    return a, b

a, b = create_cycle()
del a
del b
# 由于循环引用，a 和 b 无法通过引用计数自动释放
gc.collect()  # 手动调用垃圾收集器
# 垃圾收集器会检测到循环引用，并释放这些对象的内存

4. 内存池

Python 使用内存池来管理小对象（如整数和短字符串）的内存，避免频繁分配和释放内存。

例子：

python 复制代码 
a = 5
b = 5
# 在 Python 中，整数对象 5 是从一个整数池中分配的，a 和 b 实际上引用同一个对象
print(a is b)  # 输出 True，表明 a 和 b 引用的是同一个对象

a = 1000
b = 1000
# 对于较大的整数，Python 可能不使用内存池，因此 a 和 b 可能是不同的对象
print(a is b)  # 输出 False
对象池（Object Pools）

定义与目的 ：

对象池是一种设计模式，主要用于管理对象的复用。通过从对象池中分配小对象，可以最小化内存碎片并提高性能。

实例 ：

假设我们有一个游戏应用，游戏中需要频繁创建和销毁子弹对象。每次创建和销毁对象都会导致内存分配和释放，可能引起内存碎片，影响性能。我们可以使用对象池来解决这个问题。

具体实现：

  1. 对象池的初始化：预先创建一定数量的子弹对象，存储在一个池中。
  2. 对象获取：当需要一个子弹对象时，从对象池中取出一个可用对象，而不是重新分配内存。
  3. 对象释放：当子弹对象不再使用时，将其状态重置，并放回对象池中，以便后续复用。
python 复制代码 
class Bullet:
    def __init__(self):
        self.active = False

    def reset(self):
        self.active = True

class BulletPool:
    def __init__(self, size):
        self.pool = [Bullet() for _ in range(size)]

    def get_bullet(self):
        for bullet in self.pool:
            if not bullet.active:
                bullet.reset()
                return bullet
        return None  # 如果没有空闲对象，可以选择扩展池或返回None

    def release_bullet(self, bullet):
        bullet.active = False

# 使用对象池
bullet_pool = BulletPool(10)

# 获取一个子弹对象
bullet = bullet_pool.get_bullet()
if bullet:
    # 使用子弹对象
    pass

# 释放子弹对象
bullet_pool.release_bullet(bullet)
初始化阶段：
+---------+    +---------+    +---------+
| Bullet1 | -> | Bullet2 | -> | Bullet3 | ->  ...  (对象池中的预先创建对象)
+---------+    +---------+    +---------+

获取对象阶段：
    需要使用一个子弹对象
    ↓
+---------+    +---------+    +---------+
| Bullet1*| -> | Bullet2 | -> | Bullet3 | ->  ...  (Bullet1 被激活并使用)
+---------+    +---------+    +---------+

释放对象阶段：
    使用完的子弹对象放回池中
    ↓
+---------+    +---------+    +---------+
| Bullet1 | -> | Bullet2 | -> | Bullet3 | ->  ...  (Bullet1 被重置并放回池中)
+---------+    +---------+    +---------+
自由列表（Free Lists）

定义与目的 ：

自由列表是Python中用于重用频繁使用的小对象的一种内存管理机制。通过维护自由列表，Python可以避免重复的分配和释放开销，提高性能。

实例 ：

Python内部维护了多个自由列表，例如用于整数、浮点数等小对象。在这些列表中，常见的小对象在被释放时不会真正被销毁，而是放入自由列表中，以便下次使用时直接从列表中取出，而无需重新分配内存。

具体实现 ：

自由列表的概念在Python的C实现中，可以通过以下示例说明：

c 复制代码 
/* 在Python源码中，整数对象的自由列表实现 */
#define BLOCK_SIZE 1024

struct _intblock {
    struct _intblock *next;
    PyIntObject objects[BLOCK_SIZE];
};

static struct _intblock *block_list = NULL;
static PyIntObject *free_list = NULL;

static PyObject *
int_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    PyIntObject *v;
    if (free_list == NULL) {
        /* 没有空闲对象，分配新的内存块 */
        struct _intblock *block;
        block = (struct _intblock *)PyMem_MALLOC(sizeof(struct _intblock));
        if (block == NULL)
            return PyErr_NoMemory();
        block->next = block_list;
        block_list = block;
        /* 将新分配的内存块中的对象全部加入自由列表 */
        for (int i = 0; i < BLOCK_SIZE; i++) {
            block->objects[i].ob_type = (struct _typeobject *)free_list;
            free_list = &block->objects[i];
        }
    }
    /* 从自由列表中取出一个对象 */
    v = free_list;
    free_list = (PyIntObject *)v->ob_type;
    (void)PyObject_INIT(v, &PyInt_Type);
    return (PyObject *)v;
}
初始化阶段：
自由列表为空
[NULL]

首次分配对象：
    ↓                      (新内存块)
+---------+ +---------+ +---------+ +---------+
| Int1    | | Int2    | |  ...    | | Int1024 |
+---------+ +---------+ +---------+ +---------+
自由列表：
[Int2] -> [Int3] -> ... -> [Int1024] -> [NULL]

分配对象阶段：
    需要一个整数对象
    ↓
(Int1 被取出使用，链接重新调整)
自由列表：
[Int3] -> [Int4] -> ... -> [Int1024] -> [NULL]

释放对象阶段：
    使用完的整数对象放回自由列表
    ↓
(Int1 被重置并放回列表，链接重新调整)
自由列表：
[Int1] -> [Int3] -> [Int4] -> ... -> [Int1024] -> [NULL]

通过上述自由列表机制，当需要创建新的整数对象时，Python会首先检查自由列表。如果自由列表中有可用对象，就直接从自由列表中取出，而不需要进行新的内存分配。这种方式显著减少了内存分配和释放的开销。

5. 避免循环引用

使用弱引用来避免循环引用导致的内存泄漏。

例子：

python 复制代码 
import weakref

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

a = Node(1)
b = Node(2)
a.next = weakref.ref(b)  # 使用弱引用
b.next = weakref.ref(a)  # 使用弱引用

# 使用弱引用后，引用计数不会增加，防止循环引用导致的内存泄漏

6. 高效使用数据结构

根据使用情况选择合适的数据结构来优化内存使用。

例子：

python 复制代码 
# 使用生成器替代列表处理大数据集
def generate_numbers(n):
    for i in range(n):
        yield i

# 如果使用列表，会消耗大量内存
# numbers = list(range(1000000))

# 使用生成器，只在需要时生成数据，节省内存
numbers = generate_numbers(1000000)

7. 监控与分析

使用内存分析工具来监控和分析 Python 程序的内存使用。

例子：

python 复制代码 
# 安装 memory_profiler: pip install memory_profiler
from memory_profiler import profile

@profile
def my_function():
    a = [1] * (10**6)
    b = [2] * (2 * 10**7)
    del b
    return a

if __name__ == '__main__':
    my_function()
# 使用 memory_profiler 可以查看内存使用情况，识别可能的内存泄漏

8.Python 内存管理机制总结

分类 组件 描述 机制或方法
内存分配 栈内存 用于静态内存分配，例如函数中的局部变量。 函数调用时分配并在函数结束时自动释放。
堆内存 用于动态内存分配，存储对象和数据结构。 对象在需要时动态分配，使用自动垃圾回收管理。
对象池（Object Pools） 小对象从特定对象池中分配，以最小化内存碎片并提高性能。 使用对象池机制，多个相同类型的小对象可在池中复用，避免频繁的分配和释放开销。
自由列表（Free Lists） 重用频繁使用的小对象，避免重复的分配和释放开销。 通过维护自由列表，已释放的小对象可在后续分配中直接重用。
内存管理技术 引用计数 跟踪对象的引用数量。引用计数为零时，释放该对象的内存。 每个对象都有一个引用计数器，创建或删除引用时更新计数器。
垃圾收集（GC） 用于处理循环引用，确保互相引用但从根无法访问的对象组能够被回收。 使用代际垃圾回收器，基于对象的生命周期分为三代进行处理，定期运行回收周期。
优化与最佳实践 避免循环引用 尽量减少或避免循环引用，防止内存泄漏。 使用适当的数据结构，如 weakref 模块创建弱引用，避免强引用循环。
高效使用数据结构 根据具体用例选择合适的数据结构以优化内存使用。 例如，在处理大型序列时使用生成器（generators）替代列表，减少内存开销。
对象重用 重复使用对象特别是小对象，以减少内存分配开销。 使用对象池重用频繁创建和销毁的对象，比如子弹对象、连接对象等。
监控与分析 定期检测和分析内存使用情况以发现并处理内存泄漏。 使用工具如 memory_profiler、objgraph 等监控内存使用，并识别潜在内存泄漏。

通过上述总结表，我们可以更清晰地理解 Python 内存管理的各个组成部分及其优化策略。这能帮助开发者在编写 Python 应用程序时更高效地管理内存，提高应用性能和可靠性。

更多问题咨询

CosAI

相关推荐
一丝晨光4 分钟前
C++、Ruby和JavaScript
java·开发语言·javascript·c++·python·c·ruby
天上掉下来个程小白7 分钟前
Stream流的中间方法
java·开发语言·windows
xujinwei_gingko18 分钟前
JAVA基础面试题汇总（持续更新）
java·开发语言
sp_wxf27 分钟前
Lambda表达式
开发语言·python
Fairy_sevenseven39 分钟前
【二十八】【QT开发应用】模拟WPS Tab
开发语言·qt·wps
蜡笔小新星1 小时前
Python Kivy库学习路线
开发语言·网络·经验分享·python·学习
凯子坚持 c1 小时前
C语言复习概要（三）
c语言·开发语言
无限大.1 小时前
c语言200例 067
java·c语言·开发语言
余炜yw1 小时前
【Java序列化器】Java 中常用序列化器的探索与实践
java·开发语言
篝火悟者1 小时前
问题-python-运行报错-SyntaxError: Non-UTF-8 code starting with ‘\xd5‘ in file 汉字编码问题
开发语言·python
热门推荐
01分享几个惊艳的 Three.js 个人站点02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04组基轨迹建模 GBTM的介绍与实现（Stata 或 R）05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07CTF网络安全大赛简单的web抓包题目：HEADache08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10springer 在线投稿编译踩坑