发布于 由admin

Python高级技术之：`Python`内存泄漏的定位与排查：`tracemalloc`和`memory_profiler`的使用。

各位老铁，晚上好！今天咱们聊聊Python内存泄漏这件让人头疼的事儿，以及怎么用tracemalloc和memory_profiler这两个神器把它揪出来。

开场白：内存泄漏，你这个磨人的小妖精！

话说，写Python代码，那叫一个行云流水，一气呵成。但是，爽完之后，可能就得面对一个令人沮丧的问题：内存泄漏！就像你辛辛苦苦攒了点钱，结果发现有个小偷在你背后偷偷摸摸地拿，时间长了，家底都被掏空了。

内存泄漏是指程序在分配内存后，无法释放不再使用的内存，导致可用内存逐渐减少，最终可能导致程序崩溃或者运行缓慢。在Python中，由于有垃圾回收机制（Garbage Collection, GC），很多人觉得内存管理是自动的，不会有内存泄漏。但是，Too young, too simple! Python的GC也不是万能的，有些情况下它也搞不定。

Python内存泄漏的常见原因

  • 循环引用： 这是最常见的罪魁祸首。如果两个或多个对象相互引用，形成一个环，而没有其他对象引用这个环，GC就无法回收它们。
  • 全局变量： 全局变量的生命周期很长，如果一直持有大量数据，就可能导致内存泄漏。
  • C扩展中的内存管理错误： 如果你的Python代码调用了C扩展，而C扩展中的内存管理不当，也可能导致内存泄漏。
  • 未关闭的文件/socket等资源： 打开的文件、socket连接等资源如果没有及时关闭，也会占用内存。
  • 缓存： 有些缓存如果无限增长，也会导致内存泄漏。

神器一：tracemalloc——追踪你的内存分配

tracemalloc是Python 3.4引入的一个模块，它可以用来追踪Python的内存分配。它记录了每个内存块是由哪个代码分配的，以及分配的大小。就像一个内存警察，记录了每个内存块的“户口”信息。

tracemalloc的基本用法

  1. 启动tracemalloc:

    import tracemalloc

tracemalloc.start()

  2. 获取快照（Snapshot）： 快照记录了当前内存分配的状态。可以获取多个快照，然后比较它们之间的差异，找出内存增长的地方。

    snapshot1 = tracemalloc.take_snapshot()
# ... 执行一些操作 ...
snapshot2 = tracemalloc.take_snapshot()

  3. 比较快照：

    top_stats = snapshot2.compare_to(snapshot1, 'lineno') # 按照行号排序
for stat in top_stats[:10]: # 显示前10个差异最大的地方
    print(stat)

    compare_to方法可以指定不同的排序方式，例如'lineno' (行号), 'filename' (文件名), 'size' (大小)等等。

一个简单的tracemalloc示例

import tracemalloc

def allocate_memory():
    my_list = []
    for i in range(100000):
        my_list.append(i)
    return my_list # 注意，这里我们故意返回了my_list，模拟内存泄漏

tracemalloc.start()

snapshot1 = tracemalloc.take_snapshot()

my_list = allocate_memory() # 调用函数，分配内存

snapshot2 = tracemalloc.take_snapshot()

top_stats = snapshot2.compare_to(snapshot1, 'lineno')

print("[ Top 10 differences ]")
for stat in top_stats[:10]:
    print(stat)

在这个例子中，allocate_memory函数创建了一个很大的列表，并将其返回。虽然函数执行完毕，但是这个列表仍然被my_list变量引用，导致内存无法被释放。tracemalloc可以帮助我们找到这个内存分配的位置。

tracemalloc的进阶用法：过滤和分组

  • 过滤： 可以使用Snapshot.filter_traces()方法来过滤快照中的trace，只显示特定文件或者函数中的内存分配。

    snapshot.filter_traces((
    tracemalloc.Filter(inclusive=True, filename="my_module.py"),
))

  • 分组： 可以使用Snapshot.statistics()方法按照文件名、行号等对内存分配进行分组统计。

    stats = snapshot.statistics('filename')
for stat in stats[:10]:
    print(stat)

神器二：memory_profiler——逐行分析内存使用

memory_profiler是一个第三方库，它可以逐行分析Python代码的内存使用情况。它提供了@profile装饰器，可以标记需要分析的函数，然后运行脚本，就可以得到每个函数、每行代码的内存使用报告。

memory_profiler的安装

pip install memory_profiler

memory_profiler的基本用法

  1. 使用@profile装饰器： 在需要分析的函数前加上@profile装饰器。

    from memory_profiler import profile

@profile
def my_function():
    # ... 一些代码 ...
    pass

  2. 运行脚本： 使用mprof run命令运行你的Python脚本。

    mprof run your_script.py

  3. 查看报告： 运行完毕后，mprof会生成一个报告文件，可以使用mprof plot命令查看图形化的内存使用报告。

    mprof plot mprofile_your_script.dat

一个简单的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()

运行mprof run your_script.py，然后运行mprof plot mprofile_your_script.dat，就可以看到一个图形化的报告，显示了my_function函数中每一行代码的内存使用情况。可以看到，b = [2] * (2 * 10 ** 7)这行代码占用了大量的内存。

memory_profiler的进阶用法：自定义输出

memory_profiler还允许你自定义输出格式，例如可以将报告输出到文件，或者使用回调函数处理报告数据。

from memory_profiler import profile

@profile(filename='memory_report.log')
def my_function():
    # ... 一些代码 ...
    pass

tracemalloc和memory_profiler的对比

特性 tracemalloc memory_profiler
精度 文件名和行号级别的内存分配追踪 逐行内存使用情况分析
性能开销 较低 较高
适用场景 查找内存泄漏的根本原因，定位内存分配的位置 详细分析代码的内存使用情况，找出内存瓶颈
Python版本 Python 3.4+ 支持Python 2.7和3.x
易用性 需要编写代码来获取快照和比较，稍微复杂 使用@profile装饰器，比较简单

实战案例：用tracemalloc解决循环引用导致的内存泄漏

假设我们有以下代码：

import tracemalloc

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

def create_circular_reference():
    node1 = Node(1)
    node2 = Node(2)
    node1.next = node2
    node2.next = node1
    return node1, node2 # 返回node1和node2，避免立即被回收

tracemalloc.start()

snapshot1 = tracemalloc.take_snapshot()

node1, node2 = create_circular_reference()

snapshot2 = tracemalloc.take_snapshot()

top_stats = snapshot2.compare_to(snapshot1, 'lineno')

print("[ Top 10 differences ]")
for stat in top_stats[:10]:
    print(stat)

# 释放引用，打破循环引用
del node1
del node2

这段代码创建了一个循环引用，导致node1和node2对象无法被GC回收。运行这段代码，tracemalloc会报告Node类的__init__方法分配了内存，并且没有被释放。

解决办法是打破循环引用。在上面的代码中，我们通过del node1和del node2释放了对这两个对象的引用，打破了循环引用，GC就可以回收它们了。

实战案例：用memory_profiler优化缓存的内存使用

假设我们有一个缓存函数：

from memory_profiler import profile

cache = {}

@profile
def expensive_function(arg):
    if arg in cache:
        return cache[arg]
    else:
        # 模拟耗时操作
        result = arg * 2
        cache[arg] = result
        return result

if __name__ == '__main__':
    for i in range(1000):
        expensive_function(i)

这个函数使用一个字典cache来缓存计算结果。但是，如果arg的取值范围很大，cache就会无限增长，导致内存泄漏。

使用memory_profiler分析这段代码，可以看到cache[arg] = result这行代码占用了大量的内存。

解决办法是使用一个有大小限制的缓存，例如使用lru_cache装饰器：

from functools import lru_cache
from memory_profiler import profile

@lru_cache(maxsize=128) # 设置最大缓存大小为128
@profile
def expensive_function(arg):
    # 模拟耗时操作
    result = arg * 2
    return result

if __name__ == '__main__':
    for i in range(1000):
        expensive_function(i)

lru_cache装饰器会自动管理缓存的大小，当缓存达到最大值时，它会删除最近最少使用的缓存项，从而避免内存泄漏。

总结：内存泄漏，见招拆招！

tracemalloc和memory_profiler是定位和排查Python内存泄漏的两大利器。tracemalloc可以帮助我们找到内存分配的位置，memory_profiler可以逐行分析代码的内存使用情况。

当然，预防胜于治疗。在编写Python代码时，要注意避免循环引用、合理使用全局变量、及时关闭文件/socket等资源、使用有大小限制的缓存等等。

记住，内存泄漏就像一个慢性病，早期可能不会引起明显的症状，但是时间长了，就会对程序的性能和稳定性造成严重的影响。所以，我们要时刻保持警惕，及时发现和解决内存泄漏问题，让我们的Python程序健康运行！

好了，今天的讲座就到这里。希望大家以后写Python代码的时候，都能把内存管理这事儿放在心上，避免被内存泄漏这个磨人的小妖精缠上！ 散会！

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注