在 Python 中卸载模块

Question

TL/DR：

import gc, sys

print len(gc.get_objects()) # 4073 objects in memory

# Attempt to unload the module

import httplib
del sys.modules["httplib"]
httplib = None

gc.collect()
print len(gc.get_objects()) # 6745 objects in memory

---

更新 我已经就这个问题联系了 Python 开发人员，确实是 not going to be possible to unload a module 完全“在未来五年内”。 （见链接）

请接受 Python 在 2.x 中确实不支持针对严重、基本、不可克服的技术问题卸载模块。

---

在我最近在我的应用程序中寻找 memleak 期间，我已将其范围缩小到模块，即我无法垃圾收集卸载的模块。使用下面列出的 any 方法来卸载模块会在内存中留下数千个对象。换句话说 - 我无法在 Python 中卸载模块......

剩下的问题是尝试以某种方式对模块进行垃圾收集。

让我们试试吧：

import gc
import sys

sm = sys.modules.copy()  # httplib, which we'll try to unload isn't yet 
                         # in sys.modules, so, this isn't the source of problem

print len(gc.get_objects()) # 4074 objects in memory

让我们保存sys.modules 的副本以便稍后尝试恢复它。 所以，这是一个基线 4074 个对象。理想情况下，我们应该以某种方式回到这一点。

让我们导入一个模块：

import httplib
print len(gc.get_objects()) # 7063 objects in memory

我们最多有 7K 个非垃圾对象。 让我们尝试从sys.modules 中删除httplib。

sys.modules.pop('httplib')
gc.collect()
print len(gc.get_objects()) # 7063 objects in memory

好吧，那没用。嗯，但__main__ 中没有引用吗？哦对了：

del httplib
gc.collect()
print len(gc.get_objects()) # 6746 objects in memory

万岁，下降 300 个物体。不过，没有雪茄，那是 4000 多件原始物品。 让我们尝试从副本中恢复sys.modules。

sys.modules = sm
gc.collect()
print len(gc.get_objects()) # 6746 objects in memory

嗯，那是没有意义的，没有改变.. 也许如果我们消灭全局变量...

globals().clear()
import gc # we need this since gc was in globals() too
gc.collect()
print len(gc.get_objects()) # 6746 objects in memory

本地人？

locals().clear()
import gc # we need this since gc was in globals() too
gc.collect()
print len(gc.get_objects()) # 6746 objects in memory

什么.. 如果我们 imported exec 内部的一个模块会怎样？

local_dict = {}
exec 'import httplib' in local_dict
del local_dict
gc.collect()
print len(gc.get_objects())  # back to 7063 objects in memory

现在，这不公平，它导入到__main__，为什么？它不应该离开local_dict...啊！我们回到完全导入的httplib。 也许我们用一个虚拟对象替换它？

from types import ModuleType
import sys
print len(gc.get_objects())  # 7064 objects in memory

血腥.....！！

sys.modules['httplib'] = ModuleType('httplib')
print len(gc.get_objects())  # 7066 objects in memory

去死模块，去死！！

import httplib
for attr in dir(httplib):
    setattr(httplib, attr, None)
gc.collect()
print len(gc.get_objects())  # 6749 objects in memory

好吧，经过所有尝试，最好的结果是从起点开始 +2675（几乎 +50%）...这只是来自一个模块...内部甚至没有任何大的东西...

好的，现在说真的，我的错误在哪里？ 如何卸载模块并清除其所有内容？ 还是 Python 的模块是一个巨大的内存泄漏？

完整源代码更易于复制：http://gist.github.com/450606

Answer 1

Python 不支持卸载模块。

但是，除非您的程序随着时间的推移加载无限数量的模块，否则这不是内存泄漏的根源。模块通常在启动时加载一次，仅此而已。您的内存泄漏很可能在其他地方。

如果您的程序确实随着时间的推移确实加载了无限数量的模块，那么您可能应该重新设计您的程序。 ;-)

Answer 2

我不确定 Python，但在其他语言中，调用 gc.collect() 的等价物不会不释放未使用的内存 - 它只会在实际需要内存时释放该内存.

否则，Python 将模块暂时保留在内存中是有意义的，以防它们需要再次加载。

Answer 3

Python's small object manager rarely returns memory back to the Operating System. 来自here 和here。所以，严格来说，python 有（通过设计）一种内存泄漏，即使对象被“gc 收集”。

Answer 4

我在python3（10年后）（现在python3.8）中找不到对此的权威观点。但是，我们现在可以在百分比方面做得更好。

import gc
import sys

the_objs = gc.get_objects()
print(len(gc.get_objects())) # 5754 objects in memory
origin_modules = set(sys.modules.keys())
import http.client # it was renamed ;)

print(len(gc.get_objects())) # 9564 objects in memory
for new_mod in set(sys.modules.keys()) - origin_modules:
    del sys.modules[new_mod]
    try:
        del globals()[new_mod]
    except KeyError:
        pass
    try:
        del locals()[new_mod]
    except KeyError:
        pass
del origin_modules
# importlib.invalidate_caches()  happens to not do anything
gc.collect()
print(len(gc.get_objects())) # 6528 objects in memory 

仅增加 13%。如果您查看在新的gc.get_objects 中加载的对象类型，其中一些是内置的、源代码、random.* 实用程序、datetime 实用程序等。我主要将这里作为更新开始@shuttle 的对话，如果我们能取得更多进展，将删除。

Answer 5

（你应该尝试写更简洁的问题；我只阅读了开头并略过了其余部分。）我在开头看到了一个简单的问题：

sm = sys.modules.copy()

您制作了 sys.modules 的副本，所以现在您的副本包含了对该模块的引用——所以它当然不会被收集。您可以使用 gc.get_referrers 查看引用它的内容。

这很好用：

# module1.py
class test(object):
    def __del__(self):
        print "unloaded module1"
a = test()

print "loaded module1"

.

# testing.py
def run():
    print "importing module1"
    import module1
    print "finished importing module1"

def main():
    run()
    import sys
    del sys.modules["module1"]
    print "finished"

if __name__ == '__main__':
    main()

module1 从 sys.modules 中删除后立即卸载，因为没有对该模块的剩余引用。 （在导入之后执行module1 = None 也可以——为了清楚起见，我只是将导入放在另一个函数中。您所要做的就是删除对它的引用。）

现在，在实践中这样做有点棘手，因为两个问题：

• 为了收集模块，对模块的所有引用都必须不可访问（与收集任何对象一样）。这意味着导入它的任何其他模块也需要取消引用并重新加载。
• 如果您从 sys.modules 中删除仍然在其他地方引用的模块，则您创建了一个不寻常的情况：该模块仍然被代码加载和使用，但模块加载器不再知道它。下次导入模块时，您将不会获得对现有模块的引用（因为您删除了该模块的记录），因此它将加载该模块的第二个共存副本。这会导致严重的一致性问题。因此，在最终从 sys.modules 中删除它之前，请确保没有对模块的剩余引用。

一般来说使用这个有一些棘手的问题：检测哪些模块依赖于你正在卸载的模块；知道是否也可以卸载它们（很大程度上取决于您的用例）；在检查所有这些的同时处理线程（看看 imp.acquire_lock）等等。

我可以设计一个这样做可能有用的案例，但大多数情况下，我建议在代码更改时重新启动应用程序。你可能只会让自己头疼。