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

相关推荐
k09331 分钟前
sourceTree回滚版本到某次提交
开发语言·前端·javascript
神奇夜光杯9 分钟前
Python酷库之旅-第三方库Pandas(202)
开发语言·人工智能·python·excel·pandas·标准库及第三方库·学习与成长
Themberfue11 分钟前
Java多线程详解⑤（全程干货！！！）线程安全问题 || 锁 || synchronized
java·开发语言·线程·多线程·synchronized·锁
plmm烟酒僧13 分钟前
Windows下QT调用MinGW编译的OpenCV
开发语言·windows·qt·opencv
千天夜21 分钟前
使用UDP协议传输视频流！（分片、缓存）
python·网络协议·udp·视频流
测试界的酸菜鱼24 分钟前
Python 大数据展示屏实例
大数据·开发语言·python
羊小猪~~28 分钟前
神经网络基础--什么是正向传播？？什么是方向传播？？
人工智能·pytorch·python·深度学习·神经网络·算法·机器学习
晨曦_子画34 分钟前
编程语言之战：AI 之后的 Kotlin 与 Java
android·java·开发语言·人工智能·kotlin
Black_Friend42 分钟前
关于在VS中使用Qt不同版本报错的问题
开发语言·qt
放飞自我的Coder1 小时前
【python ROUGE BLEU jiaba.cut NLP常用的指标计算】
python·自然语言处理·bleu·rouge·jieba分词
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解