Une analyse approfondie du mécanisme de garbage collection en Python

Grâce au mécanisme automatique de récupération de place de Python, il n'est pas nécessaire de libérer manuellement les objets lors de leur création dans Python. Ceci est très convivial pour les développeurs et évite aux développeurs de se soucier de la gestion de la mémoire de bas niveau. Mais si vous ne comprenez pas son mécanisme de garbage collection, le code Python que vous écrivez sera souvent très inefficace.

Il existe de nombreux algorithmes de garbage collection, notamment : 引用计数, 标记-清除, 分代收集, etc.

Dans python, l'algorithme de garbage collection est basé sur 引用计数, complété par deux mécanismes : 标记-清除 et 分代收集.

1 Comptage de références

1.1 Principe de l'algorithme de comptage de références

Le principe du comptage de références est relativement simple :

• Chaque objet a une propriété de comptage de références entières. Utilisé pour enregistrer le nombre de fois qu'un objet est référencé.

• Par exemple, objet A, s'il existe un objet qui fait référence à A, alors le nombre de références de A est +1.

• Lorsque la référence est supprimée, le nombre de références de A est -1.

• Lorsque le compteur de références de A est 0, cela signifie que l'objet A ne peut plus être utilisé et est directement recyclé.

Dans Python, vous pouvez obtenir la valeur du compteur de référence de l'objet spécifié via la fonction sys du module getrefcount. Prenons un exemple pratique.

import sys

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

Exécutez le code ci-dessus, vous pouvez obtenir le résultat de sortie sous la forme 2.

1.2 Conditions d'augmentation et de diminution du compteur

Comme on peut le voir ci-dessus, après avoir créé un objet A et affecté l'objet à la variable a, la référence compteur de l'objet La valeur est 2. Alors à quand le compteur +1 et à quand le compteur -1 ?

1.2.1 Conditions pour le nombre de références +1

• un objet est créé, tel que A(). Les objets
• sont référencés, tels que a=A(). Les objets
• sont utilisés comme paramètres de fonctions, telles que func(a). Les objets
• servent d'éléments conteneurs, tels que arr=[a,a].

1.2.2 Conditions pour le nombre de références -1

• L'objet est explicitement détruit, tel que del a . Les variables
• sont réaffectées à de nouveaux objets, tels que a=0.
• L'objet quitte sa portée, par exemple funclorsque la fonction termine son exécution, funcles variables locales dans la fonction (les variables globales ne le seront pas).
• Le conteneur dans lequel se trouve l'objet est détruit, ou l'objet est supprimé du conteneur.

1.2.3 Pratique du code

Afin de mieux comprendre l'augmentation et la diminution du compteur, nous exécutons le code réel et le voyons clairement en un coup d'œil.

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())

Les résultats de sortie sont les suivants :

创建对象 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 Avantages et inconvénients du comptage de références

1.3.1 Avantages du comptage de références

• Logique efficace et simple, il suffit d'ajouter et de soustraire le compteur selon les règles.
• En temps réel. Une fois que le compteur de l'objet atteint zéro, cela signifie que l'objet ne pourra plus jamais être utilisé, et qu'il n'est pas nécessaire d'attendre un temps précis pour libérer directement la mémoire.

1.3.2 Inconvénients du comptage de références

• Besoin d'allouer un espace de comptage de références à l'objet, ce qui augmente la mémoire consommation.
• Lorsque l'objet à libérer est relativement volumineux, comme un objet dictionnaire, il est nécessaire de boucler et d'imbriquer les appels à tous les objets référencés, ce qui peut prendre beaucoup de temps.
• Référence circulaire. C'est le défaut fatal du comptage de références. Le comptage de références n'a pas de solution, donc d'autres algorithmes de garbage collection doivent être utilisés pour le compléter.

2 Mark-clear

Comme mentionné dans la section précédente, le comptage de références L'algorithme ne peut pas résoudre le problème de la référence circulaire. L'objet de référence circulaire fera que notre compteur ne sera jamais égal à 0, ce qui entraînera le problème de l'impossibilité de le recycler. L'algorithme

标记-清除 est principalement utilisé pour d'éventuels problèmes de référence circulaire. L'algorithme est divisé en 2 étapes :

• étape de marquage. Traitez tous les objets comme des nœuds du graphe et construisez la structure du graphe en fonction des relations de référence des objets. Tous les objets sont parcourus à partir du nœud racine du graphique, et tous les objets visités sont marqués pour indiquer que les objets sont « accessibles ».

• Effacer la scène. Parcourez tous les objets, et si un objet n'est pas marqué comme « accessible », il sera recyclé.

Expliquez avec des exemples de code spécifiques :

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()

Dans le code ci-dessus, a et b font référence l'un à l'autre, et e fait référence à c et d . L'intégralité de la relation de référence est illustrée dans la figure ci-dessous :

如果采用引用计数器算法，那么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视频教程 】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!