Python內存管理機制


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層:操作系統進行操作

 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2020 ITdaan.com