Eine eingehende Analyse des Garbage-Collection-Mechanismus in Python

Dank des automatischen Garbage-Collection-Mechanismus von Python müssen Objekte beim Erstellen in Python nicht manuell freigegeben werden. Dies ist sehr entwicklerfreundlich und befreit Entwickler von der Sorge um die Speicherverwaltung auf niedriger Ebene. Wenn Sie den Garbage-Collection-Mechanismus jedoch nicht verstehen, ist der Python-Code, den Sie schreiben, oft sehr ineffizient.

Es gibt viele Garbage-Collection-Algorithmen, hauptsächlich darunter: 引用计数, 标记-清除, 分代收集 usw.

In python basiert der Garbage-Collection-Algorithmus auf 引用计数, ergänzt durch zwei Mechanismen: 标记-清除 und 分代收集.

1 Referenzzählung

1.1 Prinzip des Referenzzählalgorithmus

Das Prinzip der Referenzzählung ist relativ einfach :

• Jedes Objekt verfügt über eine Ganzzahl-Referenzzählereigenschaft. Wird verwendet, um die Häufigkeit aufzuzeichnen, mit der auf ein Objekt verwiesen wird.

• Zum Beispiel Objekt A: Wenn es ein Objekt gibt, das auf A verweist, dann ist der Referenzzähler von A +1.

• Wenn die Referenz gelöscht wird, beträgt der Referenzzähler von A -1.

• Wenn der Referenzzähler von A 0 ist, bedeutet dies, dass das Objekt A nicht mehr verwendet werden kann und direkt recycelt wird.

In Python können Sie den Wert des Referenzzählers des angegebenen Objekts über die Funktion sys des Moduls getrefcount abrufen. Nehmen wir ein praktisches Beispiel.

import sys

class A():
    def __init__(self):
        pass
        
a = A()
print(sys.getrefcount(a))

Führen Sie den obigen Code aus. Sie können das Ausgabeergebnis als 2 erhalten.

1.2 Bedingungen zum Erhöhen und Verringern des Zählers

Wie wir oben sehen können, wird nach dem Erstellen eines A-Objekts und dem Zuweisen des Objekts zur a-Variablen die Referenz erstellt Zähler des Objekts Der Wert ist 2. Wann steht also der Zähler +1 und wann steht der Zähler -1?

1.2.1 Bedingungen für Referenzanzahl +1

• Objekt wird erstellt, z. B. A(). Auf
• -Objekte wird verwiesen, z. B. a=A().
• -Objekte werden als Parameter von Funktionen verwendet, beispielsweise func(a).
• -Objekte dienen als Containerelemente, wie z. B. arr=[a,a].

1.2.2 Bedingungen für Referenzanzahl -1

• Das Objekt wird explizit zerstört, z. B. del a .
• -Variablen werden neuen Objekten zugewiesen, beispielsweise a=0.
• Das Objekt verlässt seinen Gültigkeitsbereich, z. B. funcwenn die Funktion die Ausführung abschließt, funclokale Variablen in der Funktion (globale Variablen nicht).
• Der Container, in dem sich das Objekt befindet, wird zerstört, oder das Objekt wird aus dem Container gelöscht.

1.2.3 Code-Praxis

Um das Erhöhen und Verringern des Zählers besser zu verstehen, führen wir den tatsächlichen Code aus und sehen ihn übersichtlich auf einen Blick.

import sys
 
class A():

    def __init__(self):
        pass
 
print("创建对象 0 + 1 =", sys.getrefcount(A()))

a = A()
print("创建对象并赋值 0 + 2 =", sys.getrefcount(a))

b = a
c = a
print("赋给2个变量 2 + 2 =", sys.getrefcount(a))

b = None
print("变量重新赋值 4 - 1 =", sys.getrefcount(a))

del c
print("del对象 3 - 1 =", sys.getrefcount(a))

d = [a, a, a]
print("3次加入列表 2 + 3 =", sys.getrefcount(a))


def func(c):
    print('传入函数 1 + 2 = ', sys.getrefcount(c))
func(A())

Die Ausgabeergebnisse lauten wie folgt:

创建对象 0 + 1 = 1
创建对象并赋值 0 + 2 = 2
赋给2个变量 2 + 2 = 4
变量重新赋值 4 - 1 = 3
del对象 3 - 1 = 2
3次加入列表 2 + 3 = 5
传入函数 1 + 2 =  3

1.3 Vor- und Nachteile der Referenzzählung

1.3.1 Vorteile der Referenzzählung

• Effiziente und einfache Logik, einfach den Zähler gemäß den Regeln addieren und subtrahieren.
• Echtzeit. Sobald der Zähler des Objekts Null erreicht, bedeutet dies, dass das Objekt nie wieder verwendet werden kann und es nicht erforderlich ist, auf eine bestimmte Zeit zu warten, um den Speicher direkt freizugeben.

1.3.2 Nachteile der Referenzzählung

• Es muss dem Objekt Referenzzählraum zugewiesen werden, was den Speicher erhöht Verbrauch.
• Wenn das freizugebende Objekt relativ groß ist, z. B. ein Wörterbuchobjekt, müssen die Aufrufe aller referenzierten Objekte in einer Schleife ausgeführt und verschachtelt werden, was lange dauern kann.
• Rundschreiben. Dies ist der schwerwiegende Fehler der Referenzzählung. Für die Referenzzählung gibt es keine Lösung, daher müssen andere Garbage-Collection-Algorithmen verwendet werden, um sie zu ergänzen.

2 Mark-clear

Wie im vorherigen Abschnitt erwähnt, die Referenzzählung Der Algorithmus kann das Problem des Zirkelverweises nicht lösen. Das Objekt des Zirkelverweises führt dazu, dass unser Zähler niemals gleich 0 ist, was zu dem Problem führt, dass er nicht recycelt werden kann. Der

标记-清除-Algorithmus wird hauptsächlich für potenzielle Zirkelverweisprobleme verwendet. Der Algorithmus ist in zwei Schritte unterteilt:

• Markierungsphase. Behandeln Sie alle Objekte als Knoten des Diagramms und erstellen Sie die Diagrammstruktur basierend auf den Referenzbeziehungen der Objekte. Alle Objekte werden vom Wurzelknoten des Diagramms durchlaufen und alle besuchten Objekte werden markiert, um anzuzeigen, dass die Objekte „erreichbar“ sind.

• Bühne frei. Durchlaufen Sie alle Objekte. Wenn festgestellt wird, dass ein Objekt nicht als „erreichbar“ markiert ist, wird es recycelt.

Erklären Sie anhand konkreter Codebeispiele:

class A():
    def __init__(self):
        self.obj = None
 
def func():
    a = A()
    b = A()
    c = A()
    d = A()

    a.obj = b
    b.obj = a
    return [c, d]

e = func()

Im obigen Code beziehen sich a und b aufeinander und e auf c und d . Die gesamte Referenzbeziehung ist in der folgenden Abbildung dargestellt:

如果采用引用计数器算法，那么a和b两个对象将无法被回收。而采用标记清除法，从根节点（即e对象）开始遍历，c、d、e三个对象都会被标记为可达，而a和b无法被标记。因此a和b会被回收。

这是读者可能会有疑问，为什么确定根节点是e，而不会是a、b、c、d呢？这里就有讲究了，什么样的对象会被看成是根节点呢？一般而言，根节点的选取包括（但不限于）如下几种：

• 当前栈帧中的本地变量表中引用的对象，如各个线程被调用的方法堆栈中使用到的参数、 局部变量、 临时变量等。
• 全局静态变量
• ...

3 分代收集

3.1 分代收集原理

在执行垃圾回收过程中，程序会被暂停，即stop-the-world。这里很好理解：你妈妈在打扫房间的时候，肯定不允许你在房间内到处丢垃圾，要不然永远也无法打扫干净。

为了减少程序的暂停时间，采用分代回收(Generational Collection)降低垃圾收集耗时。

分代回收基于这样的法则：

• 接大部分的对象生命周期短，大部分对象都是朝生夕灭。

• 经历越多次数的垃圾收集且活下来的对象，说明该对象越不可能是垃圾，应该越少去收集。

Python中，对象一共有3种世代：G0,G1,G2。

• 对象刚创建时为G0。

• 如果在一轮GC扫描中存活下来，则移至G1，处于G1的对象被扫描次数会减少。

• 如果再次在扫描中活下来，则进入G2，处于G1的对象被扫描次数将会更少。

3.2 触发GC时机

当某世代中分配的对象数量与被释放的对象之差达到某个阈值的时，将触发对该代的扫描。当某世代触发扫描时，比该世代年轻的世代也会触发扫描。

那么这个阈值是多少呢？我们可以通过代码查看或者修改，示例代码如下

import gc
threshold = gc.get_threshold()
print("各世代的阈值:", threshold)

# 设置各世代阈值
# gc.set_threshold(threshold0[, threshold1[, threshold2]])
gc.set_threshold(800, 20, 20)

输出结果如下：

各世代的阈值: (700, 10, 10)

原文地址：https://juejin.cn/post/7119018622906957854

作者：SuperHua1001

【相关推荐：Python3视频教程 】

Das obige ist der detaillierte Inhalt vonEine eingehende Analyse des Garbage-Collection-Mechanismus in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!