Adakah anda faham bagaimana pengurusan memori Python berfungsi?

Python menawarkan banyak kemudahan kepada pembangun, salah satu yang terbesar ialah pengurusan memorinya yang hampir tanpa bimbang. Pembangun tidak lagi perlu memperuntukkan, menjejak, dan memori percuma secara manual untuk objek dan struktur data dalam Python. Masa jalan melakukan semua kerja ini untuk anda, jadi anda boleh menumpukan pada menyelesaikan masalah sebenar dan bukannya mempertikaikan butiran peringkat mesin.

Walau bagaimanapun, walaupun untuk pengguna Python yang tidak berpengalaman, adalah berfaedah untuk memahami cara pengumpulan sampah Python dan pengurusan memori berfungsi. Memahami mekanisme ini akan membantu anda mengelakkan isu prestasi yang mungkin timbul dengan projek yang lebih kompleks. Anda juga boleh menggunakan alat terbina dalam Python untuk memantau tingkah laku pengurusan memori program anda.

Cara Python mengurus memori

Setiap objek Python mempunyai kiraan rujukan, juga dipanggil kiraan rujukan. refcount ialah kiraan jumlah objek lain yang memegang rujukan kepada objek tertentu. Semasa anda menambah atau mengalih keluar rujukan kepada objek, nombor itu akan naik atau turun. Apabila kiraan rujukan objek mencapai sifar, objek dilepaskan dan ingatannya dibebaskan.

Apakah rujukan? Membenarkan akses kepada mana-mana kandungan objek dengan nama atau melalui aksesor dalam objek lain.

Berikut ialah contoh mudah:

x = "Hello there"

Apabila kami mengeluarkan arahan ini kepada Python, dua perkara berlaku di bawah hud:

1. Rentetan "Hello there " dicipta sebagai objek Python dan disimpan dalam ingatan.
2. Nama x dicipta dalam ruang nama tempatan dan menghala ke objek, yang meningkatkan kiraan rujukannya sebanyak 1 hingga 1.

Jika kita sebut y = x, maka kiraan rujukan akan meningkat kepada 2 semula.

Setiap kali xandy keluar dari skop atau dialih keluar daripada ruang nama mereka, kiraan rujukan rentetan dikurangkan sebanyak 1 untuk setiap nama. Setelah kedua-dua x dan y keluar dari julat atau dipadamkan, kiraan rujukan rentetan menjadi 0 dan dipadamkan.

Sekarang, katakan kita mencipta senarai yang mengandungi rentetan seperti berikut:

x = ["Hello there", 2, False]

Rentetan kekal dalam ingatan sehingga senarai itu sendiri dipadamkan atau elemen yang mengandungi rentetan Alih keluar daripada senarai. Mana-mana daripada operasi ini akan menyebabkan satu-satunya perkara yang memegang rujukan kepada rentetan hilang.

Sekarang pertimbangkan contoh ini:

x = "Hello there" y = [x]

Jika kita mengalih keluar elemen pertama y daripada , atau memadam senarai y sepenuhnya, rentetan itu masih dalam ingatan. Ini kerana nama x mengandungi rujukan kepadanya.

Kitaran Rujukan dalam Python

Dalam kebanyakan kes, pengiraan rujukan berfungsi dengan baik. Tetapi kadangkala anda menghadapi situasi di mana dua objek masing-masing memegang rujukan kepada yang lain. Ini dipanggil tempoh rujukan. Dalam kes ini, kiraan rujukan objek tidak pernah mencapai sifar dan ia tidak pernah dipadamkan daripada ingatan.

Ini adalah contoh rekaan:

x = SomeClass()
y = SomeOtherClass()
x.item = y
y.item = x

Memandangkan x dan y memegang rujukan antara satu sama lain, ia tidak sekali-kali dipadamkan daripada sistem - walaupun tiada apa-apa lagi yang merujuknya kepada mana-mana daripadanya.

Ia sebenarnya agak biasa bagi masa jalan Python sendiri untuk menjana kitaran rujukan untuk objek. Contohnya ialah pengecualian dengan objek jejak balik yang mengandungi rujukan kepada pengecualian itu sendiri.

Ini adalah masalah dalam versi Python yang lebih awal. Objek dengan kitaran rujukan boleh terkumpul dari semasa ke semasa, yang merupakan masalah besar untuk aplikasi yang berjalan lama. Tetapi Python sejak itu telah memperkenalkan pengesanan kitaran dan sistem pengumpulan sampah untuk mengurus kitaran rujukan.

Pengumpul Sampah Python (gc)

Pengumpul sampah Python mengesan objek dengan kitaran rujukan. Ia melakukan ini dengan menjejaki objek yang "bekas" (cth. senarai, kamus, contoh kelas tersuai) dan menentukan objek yang tidak boleh diakses di tempat lain.

Setelah objek ini dipilih, pemungut sampah mengalihkannya dengan memastikan kiraan rujukannya boleh turun kepada sifar dengan selamat.

Sebahagian besar objek Python tidak mempunyai kitaran rujukan, jadi pengumpul sampah tidak perlu berjalan 24/7. Sebaliknya, pemungut sampah menggunakan beberapa heuristik untuk berjalan kurang kerap dan berjalan seefisien mungkin setiap kali.

Apabila penterjemah Python bermula, ia menjejaki bilangan objek yang telah diperuntukkan tetapi tidak dibebaskan. Sebilangan besar objek Python berumur pendek, jadi ia muncul dan hilang dengan cepat. Tetapi lama kelamaan, lebih banyak objek tahan lama akan muncul. Sebaik sahaja lebih daripada sebilangan objek sedemikian terkumpul, pemungut sampah berjalan.

Setiap kali pemungut sampah berlari, ia mengumpul semua objek yang terselamat daripada kutipan dan meletakkannya dalam kumpulan yang dipanggil generasi. Objek "generasi pertama" ini diimbas kurang kerap semasa kitaran rujukan. Mana-mana objek generasi pertama yang terselamat daripada pemungut sampah akhirnya akan dipindahkan ke generasi kedua, di mana ia diimbas dengan lebih jarang.

同样，垃圾收集器不会跟踪所有内容。例如，像用户创建的类这样的复杂对象总是被跟踪。但是不会跟踪仅包含简单对象（如整数和字符串）的字典，因为该特定字典中的任何对象都不会包含对其他对象的引用。不能保存对其他元素（如整数和字符串）的引用的简单对象永远不会被跟踪。

如何使用 gc 模块

通常，垃圾收集器不需要调整即可运行良好。Python 的开发团队选择了反映最常见现实世界场景的默认值。但是如果你确实需要调整垃圾收集的工作方式，你可以使用Python 的 gc 模块。该gc模块为垃圾收集器的行为提供编程接口，并提供对正在跟踪的对象的可见性。

gc当你确定不需要垃圾收集器时，你可以做的一件有用的事情是关闭它。例如，如果你有一个堆放大量对象的短运行脚本，则不需要垃圾收集器。脚本结束时，所有内容都将被清除。为此，你可以使用命令禁用垃圾收集器gc.disable()。稍后，你可以使用 重新启用它gc.enable()。

你还可以使用 手动运行收集周期gc.collect()。一个常见的应用是管理程序的性能密集型部分，该部分会生成许多临时对象。你可以在程序的该部分禁用垃圾收集，然后在最后手动运行收集并重新启用收集。

另一个有用的垃圾收集优化是gc.freeze(). 发出此命令时，垃圾收集器当前跟踪的所有内容都被“冻结”，或者被列为免于将来的收集扫描。这样，未来的扫描可以跳过这些对象。如果你有一个程序在启动之前导入库并设置大量内部状态，那么你可以gc.freeze()在所有工作完成后发出。这使垃圾收集器不必搜寻那些无论如何都不太可能被删除的东西。（如果你想对冻结的对象再次执行垃圾收集，请使用gc.unfreeze().）

使用 gc 调试垃圾收集

你还可以使用它gc来调试垃圾收集行为。如果你有过多的对象堆积在内存中并且没有被垃圾收集，你可以使用gc's 检查工具来找出可能持有对这些对象的引用的对象。

如果你想知道哪些对象持有对给定对象的引用，可以使用gc.get_referrers(obj)列出它们。你还可以使用gc.get_referents(obj)来查找给定对象引用的任何对象。

如果你不确定给定对象是否是垃圾收集的候选对象，gc.is_tracked(obj)请告诉你垃圾收集器是否跟踪该对象。如前所述，请记住垃圾收集器不会跟踪“原子”对象（例如整数）或仅包含原子对象的元素。

如果你想亲自查看正在收集哪些对象，可以使用 设置垃圾收集器的调试标志gc.set_debug(gc.DEBUG_LEAK|gc.DEBUG_STATS)。这会将有关垃圾收集的信息写入stderr。它将所有作为垃圾收集的对象保留在只读列表中。

避免 Python 内存管理中的陷阱

如前所述，如果你在某处仍有对它们的引用，则对象可能会堆积在内存中而不会被收集。这并不是 Python 垃圾收集本身的失败。垃圾收集器无法判断你是否不小心保留了对某物的引用。

让我们以一些防止对象永远不会被收集的指针作为结尾。

注意对象范围

如果你将对象 1 指定为对象 2 的属性（例如类），则对象 2 将需要超出范围，然后对象 1 才会：

obj1 = MyClass()
obj2.prop = obj1

更重要的是，如果这种情况发生在某种其他操作的副作用中，例如将对象 2 作为参数传递给对象 1 的构造函数，你可能不会意识到对象 1 持有一个引用：

obj1 = MyClass(obj2)

另一个例子：如果你将一个对象推入模块级列表并忘记该列表，则该对象将一直保留，直到从列表中删除，或者直到列表本身不再有任何引用。但是如果该列表是一个模块级对象，它可能会一直存在，直到程序终止。

简而言之，请注意你的对象可能被另一个看起来并不总是很明显的对象持有的方式。

使用 weakref避免引用循环

Python 的 weakref 模块允许你创建对其他对象的弱引用。弱引用不会增加对象的引用计数，因此只有弱引用的对象是垃圾回收的候选对象。

一个常见的用途weakref是对象缓存。你不希望仅仅因为它具有缓存条目而保留引用的对象，因此你将 aweakref用于缓存条目。

Memutuskan kitaran rujukan secara manual

Akhir sekali, jika anda tahu bahawa objek yang diberikan mengandungi rujukan kepada objek lain, anda sentiasa boleh memecahkan rujukan kepada objek itu secara manual. Contohnya, jika anda mempunyai instance_of_class.ref = other_object, anda boleh menetapkan instance_of_class.ref = Tiada apabila bersedia untuk memadam instance_of_class.

Dengan memahami cara pengurusan memori Python berfungsi, kami melihat cara sistem pengumpulan sampahnya membantu mengoptimumkan memori dalam program Python, dan cara mengawal penggunaan memori dan pengumpulan sampah menggunakan modul yang disediakan oleh perpustakaan standard dan tempat lain.

Tajuk asal: ​​Pengumpulan sampah python dan modul gc​​

Atas ialah kandungan terperinci Adakah anda faham bagaimana pengurusan memori Python berfungsi?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!