La colonne

tutoriel Python analysera le mécanisme de récupération de place Python aujourd'hui !

1. Collecte des déchets

Le compteur de référence est le principal, le recyclage des sous-codes et l'effacement des marques sont supplémentaires

1.1 Big Butler refchain

Dans le code source Python C, il existe une liste chaînée circulaire bidirectionnelle appelée refchain Cette liste chaînée est assez géniale car une fois qu'un objet est créé dans le programme Python, le l'objet sera ajouté à la liste chaînée refchain au milieu. En d’autres termes, il sauvegarde tous les objets.

1.2 Compteur de référence

• Il y a un ob_refcnt à l'intérieur de tous les objets de la refchain pour enregistrer le compteur de référence de l'objet actuel. Comme son nom l'indique, c'est le nombre de fois qu'il est utilisé. a été référencée.
• Lorsqu'une valeur est référencée plusieurs fois, les données ne seront pas créées à plusieurs reprises dans la mémoire, mais le compteur de référence sera +1. Lorsque l'objet est détruit, le compteur de référence sera -1. Si le compteur de référence est 0, l'objet sera supprimé de la liste refchain et détruit dans la mémoire (sans tenir compte des circonstances particulières telles que la mise en cache).

age = 18number = age  # 对象18的引用计数器 + 1del age          # 对象18的引用计数器 - 1def run(arg):
    print(arg)
run(number)   # 刚开始执行函数时，对象18引用计数器 + 1，当函数执行完毕之后，对象18引用计数器 - 1 。num_list = [11,22,number] # 对象18的引用计数器 + 1复制代码

1.3 Dégagement des marques et recyclage générationnel

La collecte des déchets basée sur des compteurs de référence est très pratique et simple, mais elle présente toujours le problème des références circulaires, ce qui entraîne l'impossibilité de recycler certaines données normalement, par exemple :

v1 = [11,22,33]        # refchain中创建一个列表对象，由于v1=对象，所以列表引对象用计数器为1.v2 = [44,55,66]        # refchain中再创建一个列表对象，因v2=对象，所以列表对象引用计数器为1.v1.append(v2)        # 把v2追加到v1中，则v2对应的[44,55,66]对象的引用计数器加1，最终为2.v2.append(v1)        # 把v1追加到v1中，则v1对应的[11,22,33]对象的引用计数器加1，最终为2.del v1    # 引用计数器-1del v2    # 引用计数器-1复制代码

• Pour le code ci-dessus, vous constaterez qu'après avoir effectué l'opération del, aucune variable n'utilisera plus les deux objets de la liste, mais en raison du problème de référence circulaire, leurs compteurs de référence ne sont pas à 0. Donc leur statut : jamais utilisé, jamais détruit. S'il y a trop de codes de ce type dans le projet, la mémoire sera consommée jusqu'à ce qu'elle soit épuisée et que le programme plante.
• Afin de résoudre le problème des références circulaires, une technologie de suppression de marques est introduite pour effectuer un traitement spécial sur les objets pouvant avoir des références circulaires. Les types d'applications circulaires possibles incluent : les listes, les tuples, les dictionnaires, les ensembles, l'auto. Définissez des classes et d'autres types qui permettent l'imbrication des données.

Marquer comme clair : créez une liste chaînée spéciale spécifiquement pour enregistrer des listes, des tuples, des dictionnaires, des collections, des classes personnalisées et d'autres objets, puis vérifiez si les objets de cette liste chaînée are Il existe une référence circulaire Si elle existe, que les compteurs de référence des deux parties soient -1.

Recyclage générationnel : Optimisez la liste chaînée dans l'effacement des marques et divisez les objets pouvant avoir des références circulaires en 3 listes chaînées s'appellent : 0/1/2 trois générations. chaque génération peut stocker des objets et des seuils. Lorsque le seuil est atteint, chaque objet de la liste chaînée correspondante sera analysé, à l'exception des références circulaires, chacun sera décrémenté de 1 et les objets avec un compteur de référence de 0 seront détruits.

// 分代的C源码#define NUM_GENERATIONS 3struct gc_generation generations[NUM_GENERATIONS] = {    /* PyGC_Head,                                    threshold,    count */
    {{(uintptr_t)_GEN_HEAD(0), (uintptr_t)_GEN_HEAD(0)},   700,        0}, // 0代
    {{(uintptr_t)_GEN_HEAD(1), (uintptr_t)_GEN_HEAD(1)},   10,         0}, // 1代
    {{(uintptr_t)_GEN_HEAD(2), (uintptr_t)_GEN_HEAD(2)},   10,         0}, // 2代};复制代码

Remarque spéciale : le seuil et le décompte de la génération 0 et des générations 1 et 2 ont des significations différentes.

Génération 0, le nombre représente le nombre d'objets dans la liste chaînée de génération 0, le seuil représente le seuil du nombre d'objets dans la liste chaînée de génération 0, s'il dépasse, une vérification par scan de génération 0 sera effectuée . Génération 1, le nombre représente le nombre d'analyses de liste chaînée de génération 0 et le seuil représente le seuil du nombre d'analyses de liste chaînée de génération 0. S'il dépasse le seuil, une vérification d'analyse de génération 1 sera effectuée. Génération 2, le nombre représente le nombre d'analyses de la liste chaînée de 1ère génération et le seuil représente le seuil du nombre d'analyses de la liste chaînée de 1ère génération. S'il dépasse le seuil, une vérification d'analyse de 2ème génération sera effectuée.

1.4 Simulation de scénarios

Le processus détaillé de gestion de la mémoire et de garbage collection sera expliqué sur la base de la couche inférieure du langage C et combiné avec des diagrammes.

Étape 1 : Lorsque l'objet age=19 est créé, l'objet sera ajouté à la liste refchain.

Étape 2 : Lorsque l'objet num_list = [11,22] est créé, l'objet liste sera ajouté à la refchain et aux générations 0.

Étape 3 : Lorsque des objets nouvellement créés font que le nombre d'objets sur la liste chaînée des générations de génération 0 est supérieur au seuil de 700, scannez et vérifiez les objets sur la liste chaînée.

Lorsque la génération 0 est supérieure au seuil, la couche inférieure n'analyse pas directement la génération 0, mais détermine d'abord si 2 et 1 dépassent également le seuil.

• Si les générations 2 et 1 n'atteignent pas le seuil, scannez la génération 0 et laissez compter les générations 1+1.
• Si la 2ème génération a atteint le seuil, concaténez les trois listes chaînées 2, 1 et 0 pour une analyse complète, et réinitialisez le décompte des 2ème, 1ère et 0ème génération à 0.
• Si la génération 1 a atteint le seuil, les deux listes chaînées de 1 et 0 sont assemblées pour être analysées, et les décomptes de toutes les générations 1 et 0 sont réinitialisés à 0.

Le La liste chaînée épissée est traitée Lors de la numérisation, la tâche principale est d'éliminer les références circulaires et de détruire les déchets. Le processus détaillé est le suivant :

• 扫描链表，把每个对象的引用计数器拷贝一份并保存到 gc_refs中，保护原引用计数器。
• 再次扫描链表中的每个对象，并检查是否存在循环引用，如果存在则让各自的gc_refs减 1 。
• 再次扫描链表，将 gc_refs 为 0 的对象移动到unreachable链表中；不为0的对象直接升级到下一代链表中。
• 处理unreachable链表中的对象的 析构函数 和 弱引用，不能被销毁的对象升级到下一代链表，能销毁的保留在此链表。析构函数，指的就是那些定义了__del__方法的对象，需要执行之后再进行销毁处理。
• 最后将 unreachable 中的每个对象销毁并在refchain链表中移除（不考虑缓存机制）。

至此，垃圾回收的过程结束。

1.5 缓存机制

从上文大家可以了解到当对象的引用计数器为0时，就会被销毁并释放内存。而实际上他不是这么的简单粗暴，因为反复的创建和销毁会使程序的执行效率变低。Python中引入了“缓存机制”机制。

例如：引用计数器为0时，不会真正销毁对象，而是将他放到一个名为 free_list 的链表中，之后会再创建对象时不会在重新开辟内存，而是在free_list中将之前的对象来并重置内部的值来使用。

• float类型，维护的free_list链表最多可缓存100个float对象。

  v1 = 3.14    # 开辟内存来存储float对象，并将对象添加到refchain链表。
  print( id(v1) ) # 内存地址：4436033488
  del v1    # 引用计数器-1，如果为0则在rechain链表中移除，不销毁对象，而是将对象添加到float的free_list.
  v2 = 9.999    # 优先去free_list中获取对象，并重置为9.999，如果free_list为空才重新开辟内存。
  print( id(v2) ) # 内存地址：4436033488
  # 注意：引用计数器为0时，会先判断free_list中缓存个数是否满了，未满则将对象缓存，已满则直接将对象销毁。复制代码

• int类型，不是基于free_list，而是维护一个small_ints链表保存常见数据（小数据池），小数据池范围：-5 <= value < 257。即：重复使用这个范围的整数时，不会重新开辟内存。

  v1 = 38    # 去小数据池small_ints中获取38整数对象，将对象添加到refchain并让引用计数器+1。
  print( id(v1))  #内存地址：4514343712
  v2 = 38 # 去小数据池small_ints中获取38整数对象，将refchain中的对象的引用计数器+1。
  print( id(v2) ) #内存地址：4514343712
  # 注意：在解释器启动时候-5~256就已经被加入到small_ints链表中且引用计数器初始化为1，
  # 代码中使用的值时直接去small_ints中拿来用并将引用计数器+1即可。另外，small_ints中的数据引用计数器永远不会为0
  # （初始化时就设置为1了），所以也不会被销毁。复制代码

• str类型，维护unicode_latin1[256]链表，内部将所有的ascii字符缓存起来，以后使用时就不再反复创建。

  v1 = "A"
  print( id(v1) ) # 输出：4517720496
  del v1
  v2 = "A"
  print( id(v1) ) # 输出：4517720496
  # 除此之外，Python内部还对字符串做了驻留机制，针对只含有字母、数字、下划线的字符串（见源码Objects/codeobject.c），如果
  # 内存中已存在则不会重新在创建而是使用原来的地址里（不会像free_list那样一直在内存存活，只有内存中有才能被重复利用）。
  v1 = "asdfg"
  v2 = "asdfg"
  print(id(v1) == id(v2)) # 输出：True复制代码

• list类型，维护的free_list数组最多可缓存80个list对象。

 v1 = [11,22,33]
print( id(v1) ) # 输出：4517628816del v1
v2 = ["你","好"]
print( id(v2) ) # 输出：4517628816复制代码

• tuple类型，维护一个free_list数组且数组容量20，数组中元素可以是链表且每个链表最多可以容纳2000个元组对象。元组的free_list数组在存储数据时，是按照元组可以容纳的个数为索引找到free_list数组中对应的链表，并添加到链表中。

v1 = (1,2)
print( id(v1) )del v1  # 因元组的数量为2，所以会把这个对象缓存到free_list[2]的链表中。v2 = ("哈哈哈","Alex")  # 不会重新开辟内存，而是去free_list[2]对应的链表中拿到一个对象来使用。print( id(v2) )复制代码

• dict类型，维护的free_list数组最多可缓存80个dict对象

  v1 = {"k1":123}
  print( id(v1) )  # 输出：4515998128
  del v1
  v2 = {"name":"哈哈哈","age":18,"gender":"男"}
  print( id(v1) ) # 输出：4515998128复制代码

C语言源码底层分析

相关免费学习推荐：python教程（视频）

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!