PHP Garbage collection est nul ou est-ce juste moi?

Question

J'ai la fonction ci-dessous que j'appelle très fréquemment dans une boucle.

J'ai attendu 5 minutes que la mémoire a grimpé de 1 Mo à 156 Mo. Est-ce que le collabateur de garabage de PHP doit se présenter et réduire cela à un moment donné ?!

Est-ce parce que j'ai défini la limite de mémoire à 256 Mo?

À l'écho 2,3,4 sa jolie utilisation de la mémoire constante. Il descend mon demi-million au point 4. Mais le point 1 est l'endroit où l'augmentation de la mémoire principale se produit. Probablement à cause de file_get_html chargement du fichier html en mémoire.

Je pense que le clear et unset de la variable $html prendrait soin de cela?

function get_stuff($link, $category){ 

    $html = file_get_html(trim("$link")); 

    $article = $html->find('div[class=searchresultsWidget]', 0); 

    echo '1 - > '.convert(memory_get_usage(true)).'<br />'; 

    foreach($article->find('h4 a') as $link){ 

     $next_url = 'http://new.mysite.com'.$link->href; 

     $font_name = trim($link->plaintext);   

     $html = file_get_html(trim("$next_url")); 

     $article = $html->find('form[class=addtags]', 0); 

     $font_tags = ''; 

     foreach($article->find('ul[class=everyone_tags] li a span') as $link){ 

      $font_tags .= trim($link->innertext).','; 

     } 

     echo '2 - > '.convert(memory_get_usage(true)).'<br />'; 

     $font_name = mysql_real_escape_string($font_name); 
     $category = mysql_real_escape_string($category); 
     $font_tags = mysql_real_escape_string($font_tags); 

     $sql = "INSERT INTO tag_data (font_name, category, tags) VALUES ('$font_name', '$category', '$font_tags')"; 

     unset($font_tags); 
     unset($font_name); 
     unset($category); 

     $html->clear(); 

     mysql_query($sql); 

     unset($sql); 

     echo '3 - > '.convert(memory_get_usage(true)).'<br />';  

} 

    unset($next_url); 
    unset($link); 
    $html->clear(); 
    unset($html); 
    unset($article); 

    echo '4 - > '.convert(memory_get_usage(true)).'<br />'; 

} 

Comme vous pouvez le voir, j'ai essayé de faire usage de peu faible. Bien que ce ne soit pas bon comme je le comprends, il ne sera pas "désactivé" la mémoire dès que je l'appelle.

Merci à tous pour toute aide sur la façon dont je peux réduire cette augmentation de la mémoire.

Answer 1

Il y a une fuite de mémoire connu avec file_get_html(): http://simplehtmldom.sourceforge.net/manual_faq.htm#memory_leak

La solution est d'utiliser

$html->clear(); 

Ce qui vous faites, mais: Vous utilisez html $ à la fois à l'intérieur et à l'extérieur du boucle. À l'intérieur de la boucle, vous appelez $ html-> clear(), puis à nouveau près de la fin de votre fonction $ html-> clear() (je suppose que vous récupérez votre référence d'objet file_get_html() initiale). Ce dernier appel ne fait rien. Vous perdez la mémoire avec l'appel $html = file_get_html() initial. Essayez d'utiliser une variable différente ($ html1, peut-être?) Dans votre boucle et voyez ce qui se passe.

Answer 2

Le but du collecteur d'ordures est uniquement d'attraper des références circulaires.

S'il n'y en a pas, les variables sont immédiatement éliminées une fois que leur compte de référence atteint 0.

Je ne recommande pas que vous utilisez unset, sauf dans des cas exceptionnels. Utilisez plutôt des fonctions et utilisez les variables pour sortir de la portée afin de récupérer la mémoire. À part cela, nous ne pouvons pas vous décrire ce qui se passe exactement parce que nous devrions savoir exactement ce que fait le simple analyseur DOM. Il y a peut-être des références circulaires ou des ressources globales contenant une référence, mais il serait difficile de le savoir.

Voir reference counting basics et collecting cycles.

Answer 3

PHP n'avait pas de ramasse-miettes correct until 5.3. Il utilisait essentiellement le comptage de références, ce qui laissait des références circulaires en place jusqu'à la fin du script (par exemple $a =& $a est circulaire). De plus, le code de nettoyage que DID a fait ne fonctionnerait que si la pression de la mémoire l'exigeait. par exemple. inutile de faire un cycle de nettoyage coûteux si la mémoire nouvellement libérée n'était pas nécessaire. À partir de 5.3, il y a un garbage collector approprié, et vous pouvez le forcer à courir avec gc_enable() et gc_collect_cycles().