Une plongée profonde dans le mécanisme de collecte interne de PHP

Le mécanisme de collecte des ordures de PHP est basé sur le comptage de référence, mais les références circulaires doivent être traitées par un collecteur de déchets circulaires périodique; 1. Le nombre de références libère la mémoire immédiatement lorsqu'il n'y a pas de référence à la variable; 2. Référence La référence fait que la mémoire ne peut pas être automatiquement libérée, et cela dépend de GC à détecter et à nettoyer; 3. GC est déclenché lorsque la "racine possible" Zval atteint le seuil ou appelle manuellement gc_collect_cycles (); 4. Les applications PHP à long terme devraient surveiller GC_Status () et appeler GC_COLLECT_CYCLES () à temps pour éviter la fuite de mémoire; 5. Les meilleures pratiques incluent d'éviter les références circulaires, en utilisant gc_disable () pour optimiser les zones clés de performance et les objets de déréférence via la méthode claire () de l'ORM, et en fin de compte, garantissant une gestion efficace de la mémoire pour faire face à des scénarios complexes.

Le mécanisme de collecte des ordures de PHP (GC) est souvent négligé par les développeurs qui supposent que, en tant que langage de script de haut niveau, la gestion de la mémoire est entièrement abstraite. Bien que PHP gère automatiquement le nettoyage de la mémoire grâce à la comptage des références, en comprenant son processus de collecte interne des ordures, en particulier la façon dont il traite des références circulaires et du nettoyage des ressources - peut aider à optimiser les performances et à éviter les fuites de mémoire dans des scripts de longue durée ou des applications complexes.

Prenons une plongée profonde dans la façon dont PHP gère la mémoire et la collecte des ordures sous le capot.

Comment PHP gère la mémoire: comptage de référence

À son cœur, PHP utilise le comptage de référence comme méthode principale pour suivre et gérer la mémoire. Chaque variable en PHP est représentée en interne en tant que zval (valeur zend), qui contient la valeur et le type de type de métadonnées et de référence.

Chaque fois qu'une variable est attribuée ou transmise, le nombre de références de son zval augmente. Lorsqu'une variable s’écarte ou est non définie, le nombre de références diminue. Une fois que le nombre atteint zéro, PHP libère immédiatement la mémoire associée.

Par exemple:

 $ a = "bonjour";
$ b = $ a; // Refcount devient 2
unset ($ a); // Refcount tombe à 1
Unset ($ b); // Refcount tombe à 0 → mémoire libérée

Ce système est efficace et déterminée - la mémoire est libérée dès qu'elle n'est plus nécessaire, sauf lorsque des références circulaires sont impliquées.

Le problème: références circulaires

Le comptage de référence échoue lorsque des références circulaires se produisent - lorsque deux ou plusieurs objets se réfèrent les uns aux autres, créant un cycle qui maintient leur nombre de références au-dessus de zéro, même lorsqu'ils ne sont plus accessibles à partir de la racine de l'application.

Exemple:

 classe node {
    public $ parent;
}

$ a = new node ();
$ b = new node ();
$ a-> parent = $ b;
$ b-> parent = $ a;

Unset ($ a, $ b); // RefCount n'atteint pas zéro en raison du cycle

Même si $a et $b sont non set, chacun tient une référence à l'autre, donc leur zval s ne se nettoie jamais. Cela crée une fuite de mémoire .

C'est là que se trouve le collectionneur de déchets cycliques de PHP.

Collectionneur de déchets cycliques de PHP

Pour résoudre ce problème, PHP implémente un collecteur de déchets cycliques qui s'exécute périodiquement pour détecter et nettoyer les références circulaires. Il a été introduit dans PHP 5.3 et fonctionne parallèlement au comptage de référence.

Comment ça marche

Le GC ne fonctionne pas sur chaque sortie unset() ou de portée. Au lieu de cela, il se déclenche dans des conditions spécifiques:

• Lorsque le nombre de «racines possibles», les zvals atteignent un seuil (par défaut: 10 000).
• Ou déclenché manuellement via gc_collect_cycles() .

Une "racine possible" est un zval avec un nombre de références> 0 qui pourrait faire partie d'un cycle. Lorsque ces objets sont détectés, ils sont ajoutés à un tampon racine .

Lorsque le tampon se remplit, le GC de PHP exécute un algorithme de détection de cycle biphasé:

1. MARQUE PHASE : Traversez tous les objets racinaires possibles et marquez-les comme "gris".
2. Phase de scan : pour chaque objet, décrémentez le nombre de références de ses enfants. Si le refrot d'un enfant reste> 0 mais n'était pas une racine, cela fait partie d'un cycle.

Les objets identifiés comme faisant partie d'un cycle sont ensuite nettoyés et leur mémoire est libérée.

Vous pouvez déclencher cela manuellement:

 gc_collect_cycles (); // Force GC Run

Et surveillez-le:

 var_dump (gc_enabled ()); // bool (vrai)
var_dump (gc_status ()); // montre des courses, collectées, etc.

Considérations de performance

Bien que le GC empêche les fuites de mémoire, elle n'est pas gratuite:

• Il ajoute des frais généraux lors du suivi des cycles potentiels.
• L'exécution gc_collect_cycles() peut trop fréquemment dégrader les performances.
• Dans la plupart des scripts Web (demandes de courte durée), l'impact est négligeable car la mémoire est libérée à la fin de la demande.

Cependant, dans les applications PHP de longue durée (par exemple, les démons, les travailleurs de la CLI ou les serveurs basés sur Swoole), les cycles non collectés peuvent s'accumuler et provoquer des ballonnements de mémoire.

Meilleures pratiques

• Évitez les références circulaires lorsque cela est possible (par exemple, utilisez des références faibles ou des cycles de rupture manuellement).
• Appelez gc_disable() dans des sections critiques de performance si vous êtes certain qu'il n'y a pas de cycles.
• Utilisez gc_enable() et surveillez gc_status() dans des scripts de longue date pour suivre la collection.
• Utilisation de la mémoire de profil avec des outils comme memory_get_usage() et xdebug.

Exemple du monde réel: entités ORM

Des cadres comme la doctrine créent souvent des graphiques d'objets où les entités se référencent (par exemple, le profil utilisateur ↔). S'il n'est pas géré soigneusement, ceux-ci peuvent former des cycles.

Solution:

• Utilisez __destruct() pour briser les références.
• Ou comptez sur l'unité de travail de la doctrine pour gérer les cycles de vie des objets et claire les références après la chasse d'eau.

 fonction processUsers () {
    $ utilisateurs = $ entityManager-> getRepository (user :: class) -> findall ();
    foreach ($ utilisateurs comme $ utilisateur) {
        // processus...
    }
    $ entityManager-> clear (); // détache tous les objets
    gc_collect_cycles (); // Nettoyez tous les cycles persistants
}

Conclusion

La collecte des ordures de PHP est un système hybride:

• Le comptage de référence gère instantanément le nettoyage de la mémoire.
• Le GC cyclique intervient pour nettoyer les références circulaires, mais uniquement lorsque cela est nécessaire.

Bien que la plupart des développeurs n'aient pas besoin d'y penser pendant les cycles de demande Web typiques, la compréhension de ce mécanisme devient critique lors de la création d'applications PHP à long terme ou de la gestion de graphiques d'objets complexes.

Le point à retenir? PHP a un collectionneur de déchets, mais ce n'est pas un GC traditionnel de traçage comme à Java ou GO. Il s'agit d'une solution ciblée pour les cycles, travaillant sur le comptage des références.

Ainsi, bien que vous puissiez principalement faire confiance à PHP pour nettoyer après lui-même, être conscient des références circulaires et l'utilisation d'outils comme gc_status() et gc_collect_cycles() vous donnent un contrôle plus fin en cas de besoin.

Fondamentalement: le comptage des références fait le levage de lourds, et le GC est l'équipe de nettoyage des cas de bord.

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!