Comment maîtriser le mécanisme de récupération de place de 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 la création d'objets 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. Python 的自动垃圾回收机制，在 Python 中创建对象时无须手动释放。这对开发者非常友好，让开发者无须关注低层内存管理。但如果对其垃圾回收机制不了解，很多时候写出的 Python 代码会非常低效。

垃圾回收算法有很多，主要有： 引用计数 、 标记-清除 、 分代收集 等。

在 python 中，垃圾回收算法以 引用计数 为主， 标记-清除 和 分代收集 两种机制为辅。

1 引用计数

1.1 引用计数算法原理

引用计数原理比较简单：

每个对象有一个整型的引用计数属性。用于记录对象被引用的次数。例如对象 A ，如果有一个对象引用了 A ，则 A 的引用计数 +1 。当引用删除时， A 的引用计数 -1 。当 A 的引用计数为0时，即表示对象 A 不可能再被使用，直接回收。

在 Python 中，可以通过 sys 模块的 getrefcount 函数获取指定对象的引用计数器的值，我们以实际例子来看。

import sys

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

运行上面代码，可以得到输出结果为 2 。

1.2 计数器增减条件

上面我们看到，创建一个 A 对象，并将对象赋值给 a 变量后，对象的引用计数器值为 2 。那么什么时候计数器会 +1 ，什么时候计数器会 -1 呢？

1.2.1 引用计数+1的条件

A()
a=A()
func(a)
arr=[a,a]

1.2.2 引用计数-1的条件

对象被显式销毁，如 del a 。变量重新赋予新的对象，例如 a=0 。对象离开它的作用域，如 func 函数执行完毕时， func 函数中的局部变量（全局变量不会）。

对象所在的容器被销毁，或从容器中删除对象。

1.2.3 代码实战

为了更好的理解计数器的增减，我们运行实际代码，一目了然。

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

输出结果如下：

创建对象 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 引用计数的优点与缺点

1.3.1 引用计数优点

• 高效、逻辑简单，只需根据规则对计数器做加减法。

• 实时性。一旦对象的计数器为零，就说明对象永远不可能再被用到，无须等待特定时机，直接释放内存。

1.3.2 引用计数缺点

需要为对象分配引用计数空间，增大了内存消耗。

当需要释放的对象比较大时，如字典对象，需要对引用的所有对象循环嵌套调用，可能耗时比较长。

循环引用。 这是引用计数的致命伤，引用计数对此是无解的，因此必须要使用其它的垃圾回收算法对其进行补充。

2 标记-清除

上一小节提到，引用计数算法无法解决循环引用问题，循环引用的对象会导致大家的计数器永远都不会等于 0 ，带来无法回收的问题。

标记-清除 算法主要用于潜在的循环引用问题，该算法分为2步：

1. 标记阶段。将所有的对象看成图的节点，根据对象的引用关系构造图结构。从图的根节点遍历所有的对象，所有访问到的对象被打上标记，表明对象是“可达”的。

2. 清除阶段。遍历所有对象，如果发现某个对象没有标记为“可达”，则就回收。

以具体代码示例说明：

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

上面代码中，a和b相互引用，e引用了c和d。整个引用关系如下图所示

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

Il existe de nombreux algorithmes de garbage collection, les principaux sont : Reference Counting, Mark-Clear, Generational Collection, etc. 🎜🎜En python, l'algorithme de garbage collection est principalement basé sur le comptage de références, le mark-clear et la collection générationnelle Deux mécanismes sont complétés. 🎜

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 un attribut de comptage de références entier. Utilisé pour enregistrer le nombre de fois qu'un objet est référencé. Par exemple, objet A, si un objet 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 d'un objet spécifié via la fonction getrefcount du module sys. à un exemple pratique. 🎜

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

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

🎜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 nous pouvons le voir ci-dessus, après avoir créé un objet A et attribué l'objet à la variable a, le référence de l'objet La valeur du compteur est 2 . Alors, quand le compteur sera-t-il +1 et quand le compteur sera-t-il -1 ? 🎜

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

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

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

🎜L'objet est explicitement détruit, tel que del a code >. La variable est réaffectée à un nouvel objet, tel que <code>a=0. L'objet quitte sa portée, comme func Lorsque la fonction termine son exécution, func les 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 lui-même et le voyons clairement d'un coup d'œil. 🎜rrreee🎜Les résultats de sortie sont les suivants : 🎜rrreee

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

🎜 Nécessité d'allouer de l'espace de comptage de références aux objets, ce qui augmente la consommation de mémoire. 🎜🎜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érences circulaires. 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, l'algorithme de comptage de références ne peut pas résoudre le problème des références circulaires. Les objets référencés de manière circulaire feront que notre compteur ne sera jamais égal à 0, ce qui pose le problème de ne pas pouvoir être recyclé. 🎜🎜L'algorithme Mark-Clear est principalement utilisé pour les problèmes potentiels de référence circulaire. L'algorithme est divisé en 2 étapes : 🎜

1. 🎜é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 ». 🎜
2. 🎜Phase claire. 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 : 🎜rrreee🎜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🎜🎜 🎜🎜Si l'algorithme du compteur de référence est utilisé, les deux objets a et b ne seront pas recyclés. En utilisant la méthode mark et clear, en commençant par le nœud racine (c'est-à-dire l'objet e), les trois objets c, d et e seront marqués comme accessibles, mais a et b ne peuvent pas être marqués. Donc a et b seront recyclés. 🎜

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

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

• 全局静态变量

• ...

3 分代收集

3.1 分代收集原理

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

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

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

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

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

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

1. 对象刚创建时为 G0 。

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

3. 如果再次在扫描中活下来，则进入 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)

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!