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

相关推荐
Evand J1 小时前
LOS/NLOS环境建模与三维TOA定位，MATLAB仿真程序，可自定义锚点数量和轨迹点长度
开发语言·matlab
LucianaiB1 小时前
探索CSDN博客数据：使用Python爬虫技术
开发语言·爬虫·python
Ronin3051 小时前
11.vector的介绍及模拟实现
开发语言·c++
计算机学长大白2 小时前
C中设计不允许继承的类的实现方法是什么？
c语言·开发语言
PieroPc3 小时前
Python 写的 智慧记 进销存 辅助 程序 导入导出 excel 可打印
开发语言·python·excel
2401_857439695 小时前
SSM 架构下 Vue 电脑测评系统：为电脑性能评估赋能
开发语言·php
SoraLuna6 小时前
「Mac畅玩鸿蒙与硬件47」UI互动应用篇24 - 虚拟音乐控制台
开发语言·macos·ui·华为·harmonyos
xlsw_6 小时前
java全栈day20--Web后端实战(Mybatis基础2)
java·开发语言·mybatis
梧桐树04297 小时前
python常用内建模块：collections
python
Dream_Snowar7 小时前
速通Python 第三节
开发语言·python
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程