前言

我們知道，python 是一種高級編程語言，它提供了自動內(nèi)存管理的功能，即垃圾回收機制。垃圾回收機制是一種自動管理內(nèi)存的技術(shù)，它可以幫助開發(fā)者在編寫代碼時不必關(guān)注內(nèi)存的分配和釋放，從而提高開發(fā)效率。好奇的同學(xué)會問了，python的垃圾回收機制到底是如何實現(xiàn)的呢？帶著疑問，我們一起進行探索。

為啥需要垃圾回收

• 內(nèi)存泄漏：在程序運行過程中，如果開發(fā)者沒有正確地釋放不再使用的內(nèi)存，就會導(dǎo)致內(nèi)存泄漏。內(nèi)存泄漏會導(dǎo)致程序占用的內(nèi)存越來越多，最終可能導(dǎo)致程序崩潰或者系統(tǒng)變得非常緩慢。垃圾回收機制可以自動檢測和回收不再使用的內(nèi)存，避免內(nèi)存泄漏的問題。
• 簡化內(nèi)存管理：在一些低級編程語言中，開發(fā)者需要手動分配和釋放內(nèi)存，這樣容易出現(xiàn)內(nèi)存泄漏和內(nèi)存溢出的問題。而垃圾回收機制可以自動管理內(nèi)存，開發(fā)者不需要關(guān)注內(nèi)存的分配和釋放，從而提高開發(fā)效率。

總之，垃圾回收的存在是為了解決內(nèi)存泄漏和簡化內(nèi)存管理的問題。它可以自動檢測和回收不再使用的內(nèi)存，避免內(nèi)存泄漏，并提高開發(fā)效率。在高級編程語言中，垃圾回收是一項非常重要的功能。

怎么實現(xiàn)的呢

Python 的垃圾回收機制主要通過引用計數(shù)和循環(huán)引用檢測來實現(xiàn)。

引用計數(shù)

引用計數(shù)是一種簡單而高效的垃圾回收算法，它通過記錄每個對象的引用數(shù)量來判斷對象是否仍然被使用。當(dāng)一個對象的引用計數(shù)為0時，說明該對象已經(jīng)不再被使用，可以被回收。接下來，我們利用sys.getrefcount()查看變量的引用次數(shù)，這樣你一定會清晰很多。

案例一

import sys
?
a = []
?
print(sys.getrefcount(a)) # 2
?
def func(a):
 ? ?print(sys.getrefcount(a)) # 4
?
func(a)
?
print(sys.getrefcount(a)) # 2
?

• 第一個print會輸出2，有2次引用，一次來自 a，一次來自 getrefcount
• 第二個print會輸出4，有4次引用，一次來自a，一次來自python 的函數(shù)調(diào)用棧，一次來自函數(shù)參數(shù)，一次來自 getrefcount
• 第三個print會輸出2，有2次引用，一次來自a，一次來自 getrefcount

強調(diào)一點：在函數(shù)調(diào)用發(fā)生時，會產(chǎn)生額外的2次引用，一次來自函數(shù)棧，一次來自函數(shù)參數(shù)

案例二

我們在舉個例子，加深理解

import sys
?
a = []
?
print(sys.getrefcount(a)) # 2
?
b = a
?
print(sys.getrefcount(a)) # 3
?
c = b
d = b
e = c
f = e
g = d
?
print(sys.getrefcount(a)) # 8
?

可以看到a、b、c、d、e、f、g 這些變量全部指代的是同一個對象，這個對象被引用8次，所以最終輸出8

案例三

我們看看，未回收和回收后內(nèi)存的變化。

import os
import psutil
?
?
def show_memory_info(hint):
 ? ?pid = os.getpid()
 ? ?p = psutil.Process(pid)
?
 ? ?info = p.memory_full_info()
 ? ?memory = info.uss / 1024. / 1024
 ? ?print('{} memory used: {} MB'.format(hint, memory))
def func():
 ? ?show_memory_info('initial')
 ? ?a = [i for i in range(10000000)]
 ? ?show_memory_info('after a created')
?
func()
show_memory_info('finished')

我們定義了一個函數(shù)show_memory_info用來打印當(dāng)前python程序占用的內(nèi)存大小，定義了一個函數(shù)func()來創(chuàng)建變量a，在創(chuàng)建變量a之前打印占用內(nèi)存，最后在函數(shù)func()調(diào)用銷毀后，再次打印內(nèi)存占用。在看過案例一之后，相信你一定知道，函數(shù)內(nèi)部聲明的列表 a 是局部變量，在函數(shù)返回后，局部變量的引用會注銷掉；此時，列表 a 所指代對象的引用數(shù)為 0，Python 便會執(zhí)行垃圾回收。我們看看執(zhí)行結(jié)果是不是這樣：

initial memory used: 30.75 MB
after a created memory used: 415.6328125 MB
finished memory used: 30.98828125 MB

可以看到確實如此。

那我們?nèi)绻麑⒆兞柯暶鳛槿肿兞?，這樣函數(shù)銷毀后，列表的引用計數(shù)還存在，內(nèi)存應(yīng)該還是很大。測試一下：

def func():
 ? ?show_memory_info('initial')
 ? ?global a
 ? ?a = [i for i in range(10000000)]
 ? ?show_memory_info('after a created')

執(zhí)行結(jié)果如下：

initial memory used: 30.25390625 MB
after a created memory used: 415.38671875 MB
finished memory used: 415.38671875 MB

可以看到結(jié)果是滿足預(yù)期的。

那如果我們將func()函數(shù)生成的列表返回return a,然后調(diào)用函數(shù)并賦值給一個變量，此時列表引用也會存在，內(nèi)存不會釋放。測試一下

def func():
 ? ?show_memory_info('initial')
 ? ?a = [i for i in range(10000000)]
 ? ?show_memory_info('after a created')
 ? ?return a
?
f = func()

執(zhí)行結(jié)果如下：

initial memory used: 30.1875 MB
after a created memory used: 415.0703125 MB
finished memory used: 415.0703125 MB

可以看到，確實還有大量內(nèi)存被占用。

到這里，應(yīng)該對引用計數(shù)釋放內(nèi)存有一個清晰的認識了吧，現(xiàn)在，有人會問，我確實在某種場景下，需要手動釋放內(nèi)存該怎么辦呢？當(dāng)然python也是支持的，還是上面定義全局變量a的例子，我們只需要最后執(zhí)行del a，刪除對象的引用，然后強制調(diào)用gc.collect()，即可手動啟動垃圾回收。

循環(huán)引用

在上面案例三中，我們提到局部變量，在函數(shù)返回后，局部變量的引用會注銷掉?？聪旅孢@段例子：

def func():
 ? ?show_memory_info('initial')
 ? ?a = [i for i in range(10000000)]
 ? ?b = [i for i in range(10000000)]
 ? ?show_memory_info('after a, b created')
 ? ?a.append(b)
 ? ?b.append(a)
func()
show_memory_info('finished')

按照我們上面學(xué)習(xí)的，a和b都是局部變量，函數(shù)返回后，應(yīng)該引用計數(shù)會變?yōu)?，內(nèi)存會釋放，我們測試一下：

執(zhí)行結(jié)果如下：

initial memory used: 30.80078125 MB
after a, b created memory used: 801.99609375 MB
finished memory used: 801.99609375 MB

可以看到內(nèi)存并沒有釋放，說明a和b的引用計數(shù)應(yīng)該不為0。為啥出現(xiàn)這種情況呢？就是因為相互引用。那這種情況怎么解決呢？引用計數(shù)最后一部分提到，可以強制調(diào)用gc.collect()

什么是循環(huán)引用

循環(huán)引用是指兩個或多個對象之間相互引用，形成一個環(huán)狀結(jié)構(gòu)。這種情況下，引用計數(shù)算法無法正確判斷對象是否仍然被使用，因為它們的引用計數(shù)永遠不會變?yōu)?。為了解決循環(huán)引用的問題，Python 引入了垃圾回收器，它使用了一種稱為標記-清除的算法。

標記-清除算法分為兩個階段：標記階段和清除階段。在標記階段，垃圾回收器會從根對象開始遍歷所有可達對象，并將它們標記為活動對象。而在清除階段，垃圾回收器會遍歷整個堆內(nèi)存，將未標記的對象進行回收。

除了引用計數(shù)和標記-清除算法，Python 還使用了分代回收的策略。分代回收是一種基于對象存活時間的優(yōu)化策略，它將對象分為不同的代，每個代有不同的回收頻率。一般來說，新創(chuàng)建的對象會被分配到第0代，而經(jīng)過一次垃圾回收后仍然存活的對象會被提升到下一代。這樣可以減少垃圾回收的頻率，提高性能。

如何調(diào)試內(nèi)存泄漏

這里推薦objgraph，是一個可視化引用關(guān)系的包。

import objgraph
?
a = [1, 2, 3]
b = [4, 5, 6]
?
a.append(b)
b.append(a)
?
objgraph.show_refs([a])

這里通過show_refs()可以生成清晰的引用關(guān)系圖。

更多用法，可以參考文檔

最后

Python 的垃圾回收機制是一種自動管理內(nèi)存的技術(shù)，它通過引用計數(shù)和循環(huán)引用檢測來判斷對象是否仍然被使用，并使用標記-清除算法進行回收。此外，還采用了分代回收的策略來優(yōu)化性能。了解這些垃圾回收機制的工作原理對于編寫高效的 Python 代碼非常重要。

以上就是一文解密Python中的垃圾回收的詳細內(nèi)容，更多關(guān)于Python垃圾回收的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論