Comprendre la collection des ordures en javascript et au-delà

Récemment, lors d'un entretien technique, on m'a demandé comment différents langages de programmation géraient le garbage collection. C'était une question à la fois surprenante et rafraîchissante, et elle a vraiment piqué mon intérêt : je n'avais jamais rencontré une discussion aussi approfondie sur la gestion de la mémoire dans une interview auparavant. J'aime cette question et j'aimerais approfondir ce sujet dans un article de blog.

---

Une gestion efficace de la mémoire est essentielle pour les applications hautes performances. Garbage Collection (GC) Assure le recyclage automatique de la mémoire inutilisée pour éviter les fuites de mémoire et les plantages. Dans cet article, nous nous concentrerons sur le fonctionnement du garbage collection en JavaScript, explorerons d'autres méthodes utilisées dans les langages de programmation et fournirons des exemples pour illustrer ces concepts.

---

Qu'est-ce que la collecte des déchets ?

Le garbage collection est le processus de récupération de la mémoire occupée par les objets qui ne sont plus utilisés. Les langages dotés d'un garbage collection automatique résument ce processus afin que les développeurs n'aient pas à gérer manuellement la mémoire. Par exemple, JavaScript utilise un ramasse-miettes de suivi, tandis que d'autres langages utilisent des techniques différentes.

---

Collecte des déchets en JavaScript

JavaScript s'appuie sur la méthode de tracking garbage collection, en particulier l'algorithme mark-sweep. Décomposons-le :

1. Algorithme de marquage

Cet algorithme détermine quels objets en mémoire sont "atteignables" et libère ceux qui sont inaccessibles :

1. Marquer l'étape :
   • Partez d'un objet "racine" (par exemple, window dans un navigateur ou l'objet global dans Node.js).
   • Parcourez tous les objets accessibles à partir de ces objets racine et marquez-les comme « vivants ».
2. Phase claire :
   • Scannez le tas et libérez les objets qui ne sont pas marqués comme accessibles.

Exemple :

<code class="language-javascript">function example() {
  let obj = { key: "value" }; // obj 可达
  let anotherObj = obj; // anotherObj 引用 obj

  anotherObj = null; // 引用计数减少
  obj = null; // 引用计数减少到 0
  // obj 现在不可达，将被垃圾回收
}</code>

2. Collecte des déchets générationnelle

Les moteurs JavaScript modernes (tels que V8 dans Chrome/Node.js) utilisent le Generational GC pour optimiser le garbage collection. La mémoire est divisée en :

• Nouvelle génération : les objets de courte durée (tels que les variables de portée de fonction) sont stockés ici et collectés fréquemment.
• Ancienne génération : les objets à longue durée de vie (tels que les variables globales) sont stockés ici et collectés moins fréquemment.

Pourquoi le GC générationnel est-il plus efficace ?

• La plupart des objets en JavaScript sont éphémères et peuvent être collectés rapidement.
• Les objets à longue durée de vie sont déplacés vers l'ancienne génération, réduisant ainsi le besoin d'analyses fréquentes.

---

Autres stratégies de collecte des déchets

Explorons comment d'autres langages gèrent le garbage collection :

<.> 1. Comptage de référence

combien de références au comptage de référence sont dirigées vers un objet. Lorsque le nombre de références est réduit à 0, l'objet sera libéré.

Avantages:

Mémoire simple et immédiatement recyclée.

• avant de prédire.
Inconvénients:

Référence circulaire

: Si les deux objets sont référencés les uns avec les autres, leur nombre n'atteindra jamais 0.

• Exemple: (Python Reference Count)

<.> 2. Manuel de gestion de la mémoire

C

<code class="language-javascript">function example() {
  let obj = { key: "value" }; // obj 可达
  let anotherObj = obj; // anotherObj 引用 obj

  anotherObj = null; // 引用计数减少
  obj = null; // 引用计数减少到 0
  // obj 现在不可达，将被垃圾回收
}</code>

et

C Le langage oblige les développeurs à exprimer et à libérer la mémoire.

Exemple:

(C de gestion de la mémoire) Avantages:

Contrôlez complètement l'utilisation de la mémoire.

<code class="language-python">a = []
b = []
a.append(b)
b.append(a)
# 这些对象相互引用，但不可达；现代 Python 的循环收集器可以处理这种情况。</code>

Inconvénients:

fuites de mémoire (oublié de libérer la mémoire) et les pointeurs suspendus (libération prématurément de la mémoire).

<.> 3. Suivi du recyclage des ordures avec un collecteur circulaire

Certaines langues (comme Python) combinent le nombre de références de référence

et

détection du cycle
• pour traiter la référence du cycle.

Le collecteur de cycle scanne régulièrement l'objet pour détecter le cycle (le groupe d'objets de référence mutuelle qui ne peut pas être accessible à partir de l'objet racine). Une fois le cycle trouvé, le collecteur le détruira et recyclera la mémoire. Le collecteur de cycle résout le plus grand désavantage (référence du cycle) du comptage de référence pur. Ils augmentent les dépenses supplémentaires, mais assurez-vous qu'ils ne provoquent pas de fuites de mémoire en raison du cycle.

<.> 4. Dispositif d'inspection d'emprunt de Rust (pas de GC) Rust utilise une méthode différente,

évitant complètement le recyclage des ordures

. Au contraire, Rust utilise emprunter le dispositif d'inspection
• pour appliquer des règles de propriété strictes:
🎜

: Il n'y a qu'un seul propriétaire à la fois à la fois.

emprunter : Vous pouvez emprunter une référence (inhabituelle ou variable), mais n'autorisez qu'une seule référence variable pour empêcher

concours de données . Le cycle de vie

: Lorsque la valeur d'inférence du compilateur dépasse la portée de la portée et libère automatiquement la mémoire.

• Ce système garantit que la mémoire est sûre et ne nécessite pas de GC traditionnelles, de sorte que la rouille a l'avantage de performance de la gestion manuelle de la mémoire, tout en aidant à éviter les erreurs courantes telles que les pointeurs en suspension.
• Explication supplémentaire. La compétition #DATA se produit en programmation simultanée ou parallèle. Parce qu'il n'y a pas de mécanisme (tel que des verrous ou des opérations atomiques) pour coordonner ces accès de concurrence, l'état final des données partagées peut être imprévisible et incohérente. Il est difficile de trouver.

  ---

  La stratégie de recyclage des ordures compare

  ---

  方法	语言	优点	缺点
  引用计数	早期的 Python，Objective-C	立即回收，易于实现	循环引用失效
  追踪式（标记-清除）	JavaScript，Java	处理循环引用，对于大型堆效率高	停止世界暂停
  分代式 GC	JavaScript，Java	针对短暂的对象进行了优化	实现更复杂
  手动管理	C，C	完全控制	容易出错，需要仔细处理
  混合式（引用计数 循环收集器）	现代 Python	两全其美	仍然需要定期的循环检测
  借用检查器	Rust	无需 GC，防止数据竞争	学习曲线较陡峭，所有权规则

  javascript comment gérer les scènes communes

  Référence circulaire

  La récupération des ordures de suivi de JavaScript peut gérer la référence cyclique:

  Surveillance et fermeture des événements

  <code class="language-javascript">function example() {
    let obj = { key: "value" }; // obj 可达
    let anotherObj = obj; // anotherObj 引用 obj
  
    anotherObj = null; // 引用计数减少
    obj = null; // 引用计数减少到 0
    // obj 现在不可达，将被垃圾回收
  }</code>

  Si le moniteur incident n'est pas nettoyé correctement, il peut accidentellement provoquer une fuite de mémoire:
  Résumé

  <code class="language-python">a = []
  b = []
  a.append(b)
  b.append(a)
  # 这些对象相互引用，但不可达；现代 Python 的循环收集器可以处理这种情况。</code>

  ---

  JavaScript utilise

  Recychers de poubelle suivis de l'algorithme

  de la mobilisation de la mémoire de gestion.
  1. divisé GC Optimiser les performances en faisant attention à l'objet court. différentes stratégies utilisent d'autres langues:
  comptage de référence
  2. : simple mais facile à se produire. Gestion manuelle
  : entièrement contrôlé mais facile à faire des erreurs.
  3. Méthode mixte
     • : combinée avec des stratégies pour obtenir de meilleures performances. Dispositif d'inspection d'emprunt de Rust
     : pas de GC, mais il existe des règles de propriété strictes.
     Faites attention aux fuites de mémoire potentielles en JavaScript, en particulier dans les fermetures et la surveillance des événements.
     • Il s'agit d'une excellente occasion de comprendre le langage pour les stratégies de recyclage des ordures. À mon avis, la compréhension du principe de travail du recyclage des ordures peut non seulement vous aider à rédiger un code efficace, mais également à déboguer efficacement les erreurs liées à la mémoire.
     • référence
  Gestion JavaScript et mémoire: document MDN
  V8 Recyclage des ordures: blog V8 sur le recyclage des ordures

  Propriété de Rust: Rust Programming Language Books

  ---

  Recyclage des ordures Java: Document Oracle

  Python GC: Python GC Module

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!