Python內存管理機制

一、變數與對象

關係圖如下：

1、變數，通過變數指針引用對象

變數指針指向具體對象的內存空間，取對象的值。

2、對象，類型已知，每個對象都包含一個頭部信息（頭部信息：類型標識符和引用計數器）

注意：

變數名沒有類型，類型屬於對象（因為變數引用對象，所以類型隨對象），變數引用什麼類型的對象，變數就是什麼類型的。

In [32]: var1=object
In [33]: var2=var1
In [34]: id(var1) Out[34]: 139697863383968 In [35]: id(var2) Out[35]: 139697863383968

PS：id是python的內置函數，用於返回對象的身份，即對象的內存地址。

In [39]: a=123
In [40]: b=a

In [41]: id(a)
Out[41]: 23242832

In [42]: id(b)
Out[42]: 23242832

In [43]: a=456

In [44]: id(a)
Out[44]: 33166408

In [45]: id(b)
Out[45]: 23242832

3、引用所指判斷

通過is進行引用所指判斷，is是用來判斷兩個引用所指的對象是否相同。

整數

In [46]: a=1
In [47]: b=1
In [48]: print(a is b)
True

短字元串

In [49]: c="good"
In [50]: d="good"
In [51]: print(c is d)
True

長字元串

In [52]: e="very good"
In [53]: f="very good"
In [54]: print(e is f)
False

列表

In [55]: g=
In [56]: h=
In [57]: print(g is h)
False

由運行結果可知：

1、Python緩存了整數和短字元串，因此每個對象在內存中只存有一份，引用所指對象就是相同的，即使使用賦值語句，也只是創造新的引用，而不是對象本身；

2、Python沒有緩存長字元串、列表及其他對象，可以由多個相同的對象，可以使用賦值語句創建出新的對象。

二、引用計數

在Python中，每個對象都有指向該對象的引用總數---引用計數

查看對象的引用計數：sys.getrefcount

1、普通引用

In [2]: import sys

In [3]: a=[1,2,3]
In [4]: getrefcount(a)
Out[4]: 2

In [5]: b=a
In [6]: getrefcount(a)
Out[6]: 3
In [7]: getrefcount(b)
Out[7]: 3

注意：

當使用某個引用作為參數，傳遞給getrefcount時，參數實際上創建了一個臨時的引用。因此，getrefcount所得到的結果，會比期望的多1。

2、容器對象

Python的一個容器對象(比如：表、詞典等)，可以包含多個對象。

In [12]: a=[1,2,3,4,5]
In [13]: b=a

In [14]: a is b
Out[14]: True

In [15]: a[0]=6
In [16]: a
Out[16]: [6, 2, 3, 4, 5]

In [17]: a is b
Out[17]: True

In [18]: b
Out[18]: [6, 2, 3, 4, 5]

由上可見，實際上，容器對象中包含的並不是元素對象本身，是指向各個元素對象的引用。

3、引用計數增加

1、對象被創建

In [39]: getrefcount(123)
Out[39]: 6

In [40]: n=123

In [41]: getrefcount(123)
Out[41]: 7

2、另外的別人被創建

In [42]: m=n
In [43]: getrefcount(123)
Out[43]: 8

3、作為容器對象的一個元素

In [44]: a=[1,12,123]
In [45]: getrefcount(123)
Out[45]: 9

4、被作為參數傳遞給函數：foo(x)

4、引用計數減少

1、對象的別名被顯式的銷毀

In [46]: del m
In [47]: getrefcount(123)
Out[47]: 8

2、對象的一個別名被賦值給其他對象

In [48]: n=456
In [49]: getrefcount(123)
Out[49]: 7

3、對象從一個窗口對象中移除，或，窗口對象本身被銷毀

In [50]: a.remove(123)
In [51]: a
Out[51]: [1, 12]

In [52]: getrefcount(123)
Out[52]: 6

4、一個本地引用離開了它的作用域，比如上面的foo(x)函數結束時，x指向的對象引用減1。

三、垃圾回收

當Python中的對象越來越多，佔據越來越大的內存，啟動垃圾回收(garbage collection)，將沒用的對象清除。

1、原理

當Python的某個對象的引用計數降為0時，說明沒有任何引用指向該對象，該對象就成為要被回收的垃圾。比如某個新建對象，被分配給某個引用，對象的引用計數變為1。如果引用被刪除，對象的引用計數為0，那麼該對象就可以被垃圾回收。

In [74]: a=[321,123]

In [75]: del a

2、解析del

del a後，已經沒有任何引用指向之前建立的[321,123]，該表引用計數變為0，用戶不可能通過任何方式接觸或者動用這個對象，當垃圾回收啟動時，Python掃描到這個引用計數為0的對象，就將它所佔據的內存清空。

3、注意

1、垃圾回收時，Python不能進行其它的任務，頻繁的垃圾回收將大大降低Python的工作效率；

2、Python只會在特定條件下，自動啟動垃圾回收（垃圾對象少就沒必要回收）

3、當Python運行時，會記錄其中分配對象(object allocation)和取消分配對象(object deallocation)的次數。當兩者的差值高於某個閾值時，垃圾回收才會啟動。

In [93]: import gc

In [94]: gc.get_threshold　　#gc模塊中查看閾值的方法
Out[94]: (700, 10, 10)

閾值分析：

700即是垃圾回收啟動的閾值；

每10次0代垃圾回收，會配合1次1代的垃圾回收；而每10次1代的垃圾回收，才會有1次的2代垃圾回收；

當然也是可以手動啟動垃圾回收：

In [95]: gc.collect #手動啟動垃圾回收
Out[95]: 2

4、何為分代回收

Python將所有的對象分為0，1，2三代；

所有的新建對象都是0代對象；

當某一代對象經歷過垃圾回收，依然存活，就被歸入下一代對象。

四、內存池機制

Python中有分為大內存和小內存：（256K為界限分大小內存）

1、大內存使用malloc進行分配

2、小內存使用內存池進行分配

3、Python的內存池(金字塔)

第3層：最上層，用戶對Python對象的直接操作

第1層和第2層：內存池，有Python的介面函數PyMem_Malloc實現-----若請求分配的內存在1~256位元組之間就使用內存池管理系統進行分配，調用malloc函數分配內存，但是每次只會分配一塊大小為256K的大塊內存，不會調用free函數釋放內存，將該內存塊留在內存池中以便下次使用。

第0層：大內存-----若請求分配的內存大於256K，malloc函數分配內存，free函數釋放內存。

第-1，-2層：操作系統進行操作

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！