PHP peut ressentir des fuites de mémoire malgré la gestion automatique de la mémoire, en particulier avec de grandes données ou des scripts de longue durée. 1. Les références circulaires dans les objets peuvent empêcher la collecte des ordures, bien que PHP 5.3 comprenne un collecteur de cycle. 2. De grandes structures de données non non décrites après l'utilisation peuvent consommer la mémoire inutilement. 3. Les caches globales ou statiques qui se développent indéfiniment sans limites ou nettoyage contribuent également au ballonnement de la mémoire. Pour atténuer ces problèmes, les développeurs doivent utiliser des outils de profilage de mémoire, casser les cycles de référence manuellement, traiter les données en morceaux et éviter les mécanismes de mise en cache illimités.

PHP gère automatiquement la mémoire pour la plupart, ce qui est idéal pour les développeurs qui ne veulent pas allouer manuellement la mémoire et la mémoire libre comme dans les langues de niveau inférieur. Cependant, cela ne signifie pas que PHP est à l'abri des problèmes de mémoire, en particulier lorsqu'il s'agit de grands ensembles de données ou de scripts de longue durée. Des fuites de mémoire peuvent encore se produire et ils peuvent avoir un impact significatif sur les performances s'ils ne sont pas gérés correctement.

Comment PHP alloue et libère la mémoire

PHP utilise un système appelé comptage de référence pour gérer la mémoire. Chaque variable en PHP a une structure ZVAL qui contient sa valeur et un nombre de références. Lorsqu'une variable est attribuée ou transmise, PHP augmente le nombre de références. Une fois qu'il n'y a plus de références à celui-ci, le collecteur de déchets le marque pour le nettoyage.

Voici comment cela fonctionne:

• Les variables sont allouées à la mémoire lors de la création.
• Chaque fois que vous attribuez la variable à un autre nom ou le transmettez dans une fonction, le nombre de références augmente.
• Lorsque la variable sort de la portée ou est unset (), le nombre de références diminue.
• Lorsque le nombre atteint zéro, la mémoire est libérée.

Pour des structures complexes comme les tableaux et les objets, les choses deviennent plus difficiles. Par exemple, un tableau se contenant ( $arr = [$arr] ) crée une référence circulaire, que les anciennes versions de PHP n'ont pas pu nettoyer automatiquement. Mais depuis PHP 5.3, il existe un collecteur de cycle qui aide à détecter et à nettoyer ces cas.

Sources courantes de fuites de mémoire en php

Alors que PHP fait un travail décent de gestion de la mémoire, certains modèles peuvent provoquer une croissance inattendue de l'utilisation de la mémoire au fil du temps, en particulier dans les processus de longue durée (comme les scripts CLI ou les démons). Voici quelques coupables communs:

1. Références circulaires dans des objets

C'est l'une des causes classiques des fuites de mémoire. Si deux objets se référencent et rien d'autre les référence, ils devraient être à collectionner. Mais dans certains cas, surtout avant que PHP n'ait amélioré sa détection de cycle, ceux-ci pourraient persister en mémoire.

 classe A {
    public $ b;
}

classe B {
    public $ a;
}

$ a = new a ();
$ b = new b ();

$ a-> b = $ b;
$ b-> a = $ a;

// Même après l'incapacité, la mémoire peut ne pas être complètement libérée immédiatement
Unset ($ a, $ b);

Même si le PHP moderne le gère mieux, c'est toujours quelque chose à surveiller, surtout lorsque vous utilisez des auditeurs d'événements ou des conteneurs d'injection de dépendance qui contiennent des références d'objets.

2. De grandes structures de données qui ne sont pas libérées

Si vous traitez de gros tableaux ou lisez de gros fichiers en mémoire sans décoller des variables ou des données de chasse, l'utilisation de la mémoire peut ballon rapidement.

Par exemple:

 $ data = file_get_contents ('immense_file.json');
$ array = json_decode ($ data, true);
// Array de processus ...
// Si ce n'est pas non set, cela occupera la mémoire jusqu'à la fin du script

La solution? Utilisez unset() une fois que vous avez terminé avec des variables lourdes, ou traitez les données en morceaux au lieu de tout charger à la fois.

3. Caches globales ou statiques qui poussent indéfiniment

La mise en cache des données à l'échelle mondiale ou dans les propriétés statiques semble efficace, mais si elle n'est pas limitée ou effacée régulièrement, elle peut conduire à un ballonnement de mémoire.

Exemple:

 classe Cache {
    data privé statique $ = [];

    ensemble de fonctions statiques publiques ($ key, $ value) {
        self :: $ data [$ key] = $ valeur;
    }
}

Si vous continuez à appeler Cache::set() sans jamais effacer les anciennes entrées, votre utilisation de la mémoire continuera de cro?tre.

Conseils pour prévenir et déboguer les problèmes de mémoire PHP

Voici quelques étapes pratiques pour éviter et identifier les fuites de mémoire:

• Utilisez memory_get_usage() et memory_get_peak_usage()
  Ces fonctions intégrées aident à suivre l'utilisation de la mémoire lors de l'exécution du script. Ajoutez une connexion autour des parties clés de votre code pour repérer où la mémoire saute.

• évitez les caches globales / statiques sauf si nécessaire
  Si vous les utilisez, implémentez une limite TTL (temps de vivre) ou de taille pour vous assurer qu'ils ne se développent pas indéfiniment.

• Utilisez des outils comme XDebug ou Blackfire pour le profilage
  Ces outils vous aident à retracer l'allocation de la mémoire et à trouver des goulots d'étranglement. XDebug, par exemple, peut générer des fichiers Cachegrind qui montrent où la mémoire a été utilisée.

• Break Cycles explicitement
  Dans les graphiques d'objets complexes, la rupture manuelle des références (par exemple, régler les propriétés à null ) avant unset() peut aider le GC à travailler plus rapidement.

• Chunk de grandes opérations
  Au lieu de charger toutes les lignes d'une requête de base de données dans un tableau, traitez-les un par un. Idem avec les fichiers: lisez la ligne par ligne plut?t que tout en une fois.

Les fuites de mémoire en PHP ne sont pas aussi courantes que dans les langages de gestion de la mémoire manuelle, mais ils sont certainement possibles - en particulier lorsqu'ils travaillent avec des structures de données complexes ou des scripts de longue date.

Ce n'est pas compliqué, mais c'est facile à ignorer.

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!