Detaillierte Einführung in die Speicherverwaltung von Python

Sprachspeicherverwaltung ist ein wichtiger Aspekt des Sprachdesigns. Es ist ein wichtiger Faktor bei der Bestimmung der Sprachleistung. Unabhängig davon, ob es sich um die manuelle Verwaltung in der C-Sprache oder die Speicherbereinigung in Java handelt, sind sie zu den wichtigsten Funktionen der Sprache geworden. Hier nehmen wir die Python-Sprache als Beispiel, um die Speicherverwaltungsmethode einer dynamisch typisierten, objektorientierten-Sprache zu veranschaulichen.

Speichernutzung von Objekten

Die Zuweisungsanweisung ist die häufigste Funktion der Sprache. Aber auch die einfachste Zuweisungsanweisung kann sehr aussagekräftig sein. Es lohnt sich, die Zuweisungsanweisung von Python zu studieren.

a = 1

Die ganze Zahl 1 ist ein Objekt. Und a ist eine Referenz. Verweisen Sie mithilfe der Zuweisungsanweisung auf einen Punkt auf Objekt 1. Python ist eine dynamisch typisierte Sprache (siehe dynamische Typisierung), und Objekte und Referenzen sind getrennt. Python verwendet „Essstäbchen“, um echte Lebensmittelobjekte durch Referenzen zu berühren und umzudrehen.



Referenzen und Objekte
Um die Speicherung von Objekten im Speicher zu untersuchen, können wir uns an Pythons integrierte Funktion id() wenden . Es wird verwendet, um die Identität des Objekts zurückzugeben. Tatsächlich ist die sogenannte Identität hier die Speicheradresse des Objekts.

a = 1

print(id(a))
print(hex(id(a)))

Auf meinem Computer kehren sie zurück:

11246696

'0xab9c68'

jeweils dezimale und hexadezimale Darstellung des Speichers Adressen.

In Python cache diese Objekte, einschließlich Ganzzahlen und Kurzzeichen, zur Wiederverwendung. Wenn wir mehrere Referenzen gleich 1 erstellen, verweisen tatsächlich alle diese Referenzen auf dasselbe Objekt.

a = 1
b = 1

print(id(a))
print(id(b))

Das obige Programm gibt

11246696

11246696

Es ist ersichtlich, dass a und b zeigen tatsächlich auf dasselbe Zwei Verweise auf ein Objekt.

Um zu überprüfen, ob zwei Referenzen auf dasselbe Objekt verweisen, können wir das Schlüsselwort is verwenden. Dies wird verwendet, um zu bestimmen, ob die Objekte, auf die zwei Referenzen zeigen, gleich sind.

# Truea = 1
b = 1
print(a is b)

# True
a = "good"
b = "good"
print(a is b)

# False
a = "very good morning"
b = "very good morning"
print(a is b)

# False
a = []
b = []
print(a is b)

Die obige Anmerkung ist das entsprechende laufende Ergebnis. Wie Sie sehen können, gibt es nur eine Kopie jedes Objekts, da Python ganze Zahlen und kurze -Strings zwischenspeichert. Beispielsweise verweisen alle Verweise auf die Ganzzahl 1 auf dasselbe Objekt. Selbst wenn Sie eine Zuweisungsanweisung verwenden, erstellen Sie nur eine neue Referenz, nicht das Objekt selbst. Lange Zeichenfolgen und andere Objekte können mehrere identische Objekte haben, und neue Objekte können mithilfe von Zuweisungsanweisungen erstellt werden.

In Python verfügt jedes Objekt über eine Gesamtzahl von Referenzen, die auf das Objekt verweisen, d. h. die Referenzanzahl (Referenz Anzahl).

Wir können getrefcount() im sys-Paket verwenden, um den Referenzzähler eines Objekts anzuzeigen. Es ist zu beachten, dass, wenn eine Referenz als Parameter an getrefcount() übergeben wird, der Parameter tatsächlich eine temporäre Referenz erstellt. Daher ist das von getrefcount() erhaltene Ergebnis um 1 größer als erwartet.

from sys import getrefcount

a = [1, 2, 3]
print(getrefcount(a))

b = a
print(getrefcount(b))

Aufgrund des oben Gesagten geben beide getrefcounts 2 und 3 anstelle der erwarteten 1 und 2 zurück.

Objektreferenzobjekt

Ein Containerobjekt (Container) in Python, wie eine Tabelle, ein Wörterbuch usw., kann mehrere Objekte enthalten. Tatsächlich enthält das Containerobjekt nicht das Elementobjekt selbst, sondern einen Verweis auf jedes Elementobjekt.

Wir können ein Objekt auch anpassen und auf andere Objekte verweisen:

class from_obj(object):
  def init(self, to_obj):
    self.to_obj = to_obj

b = [1,2,3]
a = from_obj(b)
print(id(a.to_obj))
print(id(b))

Wie Sie sehen können, bezieht sich a auf Objekt b.

Objektreferenzobjekte sind die grundlegendste Art, Python zu strukturieren. Sogar die Zuweisungsmethode a = 1 führt tatsächlich dazu, dass ein Element mit dem Schlüsselwert „a“ des Wörterbuchs auf das ganzzahlige Objekt 1 verweist. Dieses Wörterbuchobjekt wird zum Aufzeichnen aller globalen Referenzen verwendet. Das Wörterbuch referenziert das Integer-Objekt 1. Wir können dieses Wörterbuch über die integrierte Funktion globals() anzeigen.

Wenn ein Objekt A von einem anderen Objekt B referenziert wird, wird der Referenzzähler von A um 1 erhöht.

from sys import getrefcount

a = [1, 2, 3]
print(getrefcount(a))

b = [a, a]
print(getrefcount(a))

Da Objekt b zweimal auf a verweist, erhöht sich die Referenzanzahl von a um 2.

Verweise auf Containerobjekte können sehr komplexe topologische Strukturen bilden. Wir können das objgraph-Paket verwenden, um seine Referenzbeziehungen zu zeichnen, z. B.

x = [1, 2, 3]
y = [x, dict(key1=x)]
z = [y, (x, y)]

import objgraph
objgraph.show_refs([z], filename='ref_topo.png')

objgraph ist ein Drittanbieterpaket für Python . Sie müssen xdot vor der Installation installieren.

sudo apt-get install xdot
sudo pip install objgraph

Zwei Objekte können aufeinander verweisen und so einen sogenannten Referenzzyklus bilden.

a = []
b = [a]
a.append(b)

Auch ein Objekt, das nur auf sich selbst verweisen muss, kann einen Referenzzyklus bilden.

a = []
a.append(a)
print(getrefcount(a))

引用环会给垃圾回收机制带来很大的麻烦，我将在后面详细叙述这一点。

引用减少

某个对象的引用计数可能减少。比如，可以使用del关键字删除某个引用:

from sys import getrefcount

a = [1, 2, 3]
b = a
print(getrefcount(b))

del a
print(getrefcount(b))

del也可以用于删除容器元素中的元素，比如:

a = [1,2,3]
del a[0]
print(a)

如果某个引用指向对象A，当这个引用被重新定向到某个其他对象B时，对象A的引用计数减少:

from sys import getrefcount

a = [1, 2, 3]
b = a
print(getrefcount(b))
a = 1
print(getrefcount(b))

垃圾回收

吃太多，总会变胖，Python也是这样。当Python中的对象越来越多，它们将占据越来越大的内存。不过你不用太担心Python的体形，它会乖巧的在适当的时候“减肥”，启动垃圾回收(garbage collection)，将没用的对象清除。在许多语言中都有垃圾回收机制，比如Java和Ruby。尽管最终目的都是塑造苗条的提醒，但不同语言的减肥方案有很大的差异 (这一点可以对比本文和Java内存管理与垃圾回收)。

从基本原理上，当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。比如某个新建对象，它被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。比如下面的表:

a = [1, 2, 3]
del a

del a后，已经没有任何引用指向之前建立的[1, 2, 3]这个表。用户不可能通过任何方式接触或者动用这个对象。这个对象如果继续待在内存里，就成了不健康的脂肪。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。

然而，减肥是个昂贵而费力的事情。垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。

我们可以通过gc模块的get_threshold()方法，查看该阈值:

import gc
print(gc.get_threshold())

返回(700, 10, 10)，后面的两个10是与分代回收相关的阈值，后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。

我们也可以手动启动垃圾回收，即使用gc.collect()。

分代回收

Python同时采用了分代(generation)回收的策略。这一策略的基本假设是，存活时间越久的对象，越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象，许多对象很快产生和消失，但也有一些对象长期被使用。出于信任和效率，对于这样一些“长寿”对象，我们相信它们的用处，所以减少在垃圾回收中扫描它们的频率。

Python将所有的对象分为0，1，2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收，依然存活，那么它就被归入下一代对象。垃圾回收启动时，一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收，那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后，那么会启动对0，1，2，即对所有对象进行扫描。

这两个次数即上面get_threshold()返回的(700, 10, 10)返回的两个10。也就是说，每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收。

同样可以用set_threshold()来调整，比如对2代对象进行更频繁的扫描。

import gc
gc.set_threshold(700, 10, 5)

孤立的引用环

引用环的存在会给上面的垃圾回收机制带来很大的困难。这些引用环可能构成无法使用，但引用计数不为0的一些对象。

a = []
b = [a]
a.append(b)

del a
del b

上面我们先创建了两个表对象，并引用对方，构成一个引用环。删除了a，b引用之后，这两个对象不可能再从程序中调用，就没有什么用处了。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收。



孤立的引用环
为了回收这样的引用环，Python复制每个对象的引用计数，可以记为gc_ref。假设，每个对象i，该计数为gc_ref_i。Python会遍历所有的对象i。对于每个对象i引用的对象j，将相应的gc_ref_j减1。



遍历后的结果
在结束遍历后，gc_ref不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留。而其它的对象则被垃圾回收。

总结

Python作为一种动态类型的语言，其对象和引用分离。这与曾经的面向过程语言有很大的区别。为了有效的释放内存，Python内置了垃圾回收的支持。Python采取了一种相对简单的垃圾回收机制，即引用计数，并因此需要解决孤立引用环的问题。

Python与其它语言既有共通性，又有特别的地方。对该内存管理机制的理解，是提高Python性能的重要一步。

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die Speicherverwaltung von Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!