Analyse der Entwicklung des Garbage-Collection-Mechanismus in PHP5

Vorwort

PHP ist eine verwaltete Sprache. Bei der PHP-Programmierung müssen sich Programmierer nicht manuell um die Zuweisung und Freigabe von Speicherressourcen kümmern (außer beim Schreiben von PHP- oder Zend-Erweiterungen in C), was bedeutet, dass PHP Es implementiert den Garbage Collection-Mechanismus (Garbage Collection) selbst. Wenn Sie nun die offizielle PHP-Website (php.net) besuchen, können Sie sehen, dass die beiden Zweigversionen von PHP5, PHP5.2 und PHP5.3, separat aktualisiert werden. Dies liegt daran, dass viele Projekte immer noch die 5.2-Version von PHP verwenden. und die Version 5.3 ist mit 5.2 nicht vollständig kompatibel. PHP5.3 hat viele Verbesserungen auf der Grundlage von PHP5.2 vorgenommen, darunter der Garbage-Collection-Algorithmus, der eine relativ große Änderung darstellt. In diesem Artikel werden die Garbage-Collection-Mechanismen von PHP5.2 bzw. PHP5.3 besprochen und die Auswirkungen dieser Entwicklung und Verbesserung auf Programmierer, die PHP schreiben, sowie die Probleme, auf die sie achten sollten, erörtert.

Interne Darstellung von PHP-Variablen und zugehörigen Speicherobjekten

Die Garbage Collection ist letztendlich eine Operation für Variablen und ihre zugehörigen Speicherobjekte. Bevor wir also den Garbage Collection-Mechanismus von PHP besprechen, wollen wir ihn kurz vorstellen: Die interne Darstellung von Variablen und ihren Speicherobjekten in PHP (ihre Darstellung im C-Quellcode).

Die offizielle PHP-Dokumentation unterteilt Variablen in PHP in zwei Kategorien: Skalare Typen und komplexe Typen. Zu den Skalartypen gehören Boolesche Werte, Ganzzahlen, Gleitkommatypen und Zeichenfolgen. Zu den komplexen Typen gehören auch Arrays, Objekte und Ressourcen. Es gibt auch einen speziellen NULL-Typ, der in keinen Typ unterteilt ist, sondern zu einer separaten Kategorie wird.

Alle diese Typen werden in PHP einheitlich durch eine Struktur namens zval dargestellt. Im PHP-Quellcode lautet der Name dieser Struktur „_zval_struct“. Die spezifische Definition von zval befindet sich in der Datei „Zend/zend.h“ des PHP-Quellcodes. Das Folgende ist ein Auszug des relevanten Codes.

typedef union _zvalue_value {
    long lval;                  /* long value */
    double dval;                /* double value */
    struct {
        char *val;
        int len;
    } str;
    HashTable *ht;              /* hash table value */
    zend_object_value obj;
} zvalue_value;
 
struct _zval_struct {
    /* Variable information */
    zvalue_value value;     /* value */
    zend_uint refcount__gc;
    zend_uchar type;    /* active type */
    zend_uchar is_ref__gc;
};

Die Union „_zvalue_value“ wird verwendet, um die Werte aller Variablen in PHP darzustellen. Der Grund, warum Union hier verwendet wird, liegt darin, dass ein zval jeweils nur einen Variablentyp darstellen kann. Sie können sehen, dass es in _zvalue_value nur 5 Felder gibt, in PHP jedoch 8 Datentypen, einschließlich NULL. Wie verwendet PHP also 5 Felder, um 8 Typen intern darzustellen? Dies ist einer der clevereren Aspekte des PHP-Designs. Es erreicht den Zweck der Reduzierung von Feldern durch die Wiederverwendung von Feldern. Beispielsweise werden in PHP boolesche Typen, Ganzzahlen und Ressourcen (sofern die Kennung der Ressource gespeichert ist) über das Feld lval gespeichert in PHP ist das Array eigentlich eine Hash-Tabelle); und obj speichert den Objekttyp; wenn alle Felder auf 0 oder NULL gesetzt sind, bedeutet dies in PHP, dass 5 Felder zum Speichern von 8 Arten von Werten verwendet werden.

Welchen Typ der Wert im aktuellen zval (der Werttyp ist _zvalue_value) darstellt, wird durch den Typ in „_zval_struct“ bestimmt. _zval_struct ist die spezifische Implementierung von zval in der C-Sprache. Jedes zval repräsentiert ein Speicherobjekt einer Variablen. Zusätzlich zu Wert und Typ können Sie sehen, dass es in _zval_struct zwei Felder gibt: refcount__gc und is_ref__gc. Aus ihren Suffixen können Sie schließen, dass diese beiden Typen mit der Speicherbereinigung zusammenhängen. Das ist richtig, die Garbage Collection von PHP basiert vollständig auf diesen beiden Feldern. Darunter gibt refcount__gc an, dass derzeit mehrere Variablen auf dieses zval verweisen, und is_ref__gc gibt an, ob auf das aktuelle zval verwiesen wird. Das klingt sehr verwirrend. Dies hängt mit dem „Write-On-Copy“-Mechanismus von zval zusammen. Da dieses Thema nicht im Mittelpunkt steht, werde ich hier nicht auf Details eingehen. Die Leser müssen sich nur an die Rolle des Felds refcount__gc erinnern.

Garbage-Collection-Algorithmus in PHP5.2 – Referenzzählung

Der in PHP5.2 verwendete Speicherrecycling-Algorithmus ist die berühmte Referenzzählung. Die chinesische Übersetzung dieses Algorithmus heißt „Referenzzählung“. Die Idee ist sehr intuitiv und prägnant: Weisen Sie jedem Speicherobjekt einen Zähler zu. Wenn ein Speicherobjekt erstellt wird, wird der Zähler auf 1 initialisiert (es gibt also immer eine Variable, die zu diesem Zeitpunkt auf dieses Objekt verweist). Zu diesem Speicherobjekt wird der Zähler um 1 erhöht, und jedes Mal, wenn eine Variable, die auf dieses Speicherobjekt verweist, reduziert wird, wird der Zähler um 1 dekrementiert. Wenn der Garbage-Collection-Mechanismus funktioniert, werden alle Speicherobjekte mit einem Zähler von 0 zerstört und Der Speicher, den sie belegen, wird recycelt. Das Speicherobjekt in PHP ist zval und der Zähler ist refcount__gc.

Der folgende PHP-Code demonstriert beispielsweise das Funktionsprinzip des PHP5.2-Zählers (der Zählerwert wird über xdebug ermittelt):

<?php
 
$val1 = 100; //zval(val1).refcount_gc = 1;
$val2 = $val1; //zval(val1).refcount_gc = 2,zval(val2).refcount_gc = 2(因为是Write on copy，当前val2与val1共同引用一个zval)
$val2 = 200; //zval(val1).refcount_gc = 1,zval(val2).refcount_gc = 1(此处val2新建了一个zval)
unset($val1); //zval(val1).refcount_gc = 0($val1引用的zval再也不可用，会被GC回收)
 
?>
Reference Counting简单直观，实现方便，但却存在一个致命的缺陷，就是容易造成内存泄露。很多朋友可能已经意识到了，如果存在循环引用，那么Reference Counting就可能导致内存泄露。例如下面的代码：
<?php
$a = array();
$a[] = & $a;
unset($a);
 
?>

Dieser Code erstellt zunächst das Array a, und dann lässt a Das erste Element zeigt durch Referenz auf a. Zu diesem Zeitpunkt wird der Refcount des zval von a zu 2. Dann zerstören wir die Variable a. Zu diesem Zeitpunkt ist der Refcount des zval, auf den a zunächst zeigt , aber wir haben keine Möglichkeit mehr, es zu bedienen, da es eine kreisförmige Selbstreferenz bildet, wie in der folgenden Abbildung gezeigt:

Der graue Teil zeigt an, dass dies nicht mehr der Fall ist existiert. Da der Refcount des zval, auf den a zeigt, 1 ist (durch das erste Element seiner HashTable referenziert), wird dieser zval von GC nicht zerstört und dieser Teil des Speichers wird verloren gehen.

这里特别要指出的是，PHP是通过符号表（Symbol Table）存储变量符号的，全局有一个符号表，而每个复杂类型如数组或对象有自己的符号表，因此上面代码中，a和a[0]是两个符号，但是a储存在全局符号表中，而a[0]储存在数组本身的符号表中，且这里a和a[0]引用同一个zval（当然符号a后来被销毁了）。希望读者朋友注意分清符号（Symbol）的zval的关系。

在PHP只用于做动态页面脚本时，这种泄露也许不是很要紧，因为动态页面脚本的生命周期很短，PHP会保证当脚本执行完毕后，释放其所有资源。但是PHP发展到目前已经不仅仅用作动态页面脚本这么简单，如果将PHP用在生命周期较长的场景中，例如自动化测试脚本或deamon进程，那么经过多次循环后积累下来的内存泄露可能就会很严重。这并不是我在耸人听闻，我曾经实习过的一个公司就通过PHP写的deamon进程来与数据存储服务器交互。

由于Reference Counting的这个缺陷，PHP5.3改进了垃圾回收算法。

PHP5.3中的垃圾回收算法——Concurrent Cycle Collection in Reference Counted Systems

PHP5.3的垃圾回收算法仍然以引用计数为基础，但是不再是使用简单计数作为回收准则，而是使用了一种同步回收算法，这个算法由IBM的工程师在论文Concurrent Cycle Collection in Reference Counted Systems中提出。

这个算法可谓相当复杂，从论文29页的数量我想大家也能看出来，所以我不打算（也没有能力）完整论述此算法，有兴趣的朋友可以阅读上面的提到的论文（强烈推荐，这篇论文非常精彩）。

我在这里，只能大体描述一下此算法的基本思想。

首先PHP会分配一个固定大小的“根缓冲区”，这个缓冲区用于存放固定数量的zval，这个数量默认是10,000，如果需要修改则需要修改源代码Zend/zend_gc.c中的常量GC_ROOT_BUFFER_MAX_ENTRIES然后重新编译。

由上文我们可以知道，一个zval如果有引用，要么被全局符号表中的符号引用，要么被其它表示复杂类型的zval中的符号引用。因此在zval中存在一些可能根（root）。这里我们暂且不讨论PHP是如何发现这些可能根的，这是个很复杂的问题，总之PHP有办法发现这些可能根zval并将它们投入根缓冲区。

当根缓冲区满额时，PHP就会执行垃圾回收，此回收算法如下：

1、对每个根缓冲区中的根zval按照深度优先遍历算法遍历所有能遍历到的zval，并将每个zval的refcount减1，同时为了避免对同一zval多次减1（因为可能不同的根能遍历到同一个zval），每次对某个zval减1后就对其标记为“已减”。

2、再次对每个缓冲区中的根zval深度优先遍历，如果某个zval的refcount不为0，则对其加1，否则保持其为0。

3、清空根缓冲区中的所有根（注意是把这些zval从缓冲区中清除而不是销毁它们），然后销毁所有refcount为0的zval，并收回其内存。

如果不能完全理解也没有关系，只需记住PHP5.3的垃圾回收算法有以下几点特性：

1、并不是每次refcount减少时都进入回收周期，只有根缓冲区满额后在开始垃圾回收。

2、可以解决循环引用问题。

3、可以总将内存泄露保持在一个阈值以下。

PHP5.2与PHP5.3垃圾回收算法的性能比较

由于我目前条件所限，我就不重新设计试验了，而是直接引用PHP Manual中的实验，关于两者的性能比较请参考PHP Manual中的相关章节：http://www.php.net/manual/en/features.gc.performance-considerations.php。

首先是内存泄露试验，下面直接引用PHP Manual中的实验代码和试验结果图：

<?php
class Foo
{
    public $var = &#39;3.1415962654&#39;;
}
 
$baseMemory = memory_get_usage();
 
for ( $i = 0; $i <= 100000; $i++ )
{
    $a = new Foo;
    $a->self = $a;
    if ( $i % 500 === 0 )
    {
        echo sprintf( &#39;%8d: &#39;, $i ), memory_get_usage() - $baseMemory, "\n";
    }
}
?>

Analyse der Entwicklung des Garbage-Collection-Mechanismus in PHP5

可以看到在可能引发累积性内存泄露的场景下，PHP5.2发生持续累积性内存泄露，而PHP5.3则总能将内存泄露控制在一个阈值以下（与根缓冲区大小有关）。

另外是关于性能方面的对比：

<?php
class Foo
{
    public $var = &#39;3.1415962654&#39;;
}
 
for ( $i = 0; $i <= 1000000; $i++ )
{
    $a = new Foo;
    $a->self = $a;
}
 
echo memory_get_peak_usage(), "\n";
?>

这个脚本执行1000000次循环，使得延迟时间足够进行对比。

然后使用CLI方式分别在打开内存回收和关闭内存回收的的情况下运行此脚本：

time php -dzend.enable_gc=0 -dmemory_limit=-1 -n example2.php
# and
time php -dzend.enable_gc=1 -dmemory_limit=-1 -n example2.php

在我的机器环境下，运行时间分别为6.4s和7.2s，可以看到PHP5.3的垃圾回收机制会慢一些，但是影响并不大。

PHP-Konfiguration im Zusammenhang mit dem Garbage-Collection-Algorithmus

Sie können den Garbage-Collection-Mechanismus von PHP aktivieren oder deaktivieren, indem Sie zend.enable_gc in php.ini ändern, oder Sie können ihn aktivieren, indem Sie gc_enable() oder gc_disable( ) Oder deaktivieren Sie den Garbage-Collection-Mechanismus von PHP. Auch wenn der Garbage-Collect-Mechanismus in PHP5.3 deaktiviert ist, zeichnet PHP mögliche Roots weiterhin im Root-Puffer auf, aber wenn der Root-Puffer voll ist, führt PHP die Garbage Collection nicht automatisch aus. Natürlich können Sie gc_collect_cycles manuell aufrufen jederzeit. ()-Funktion erzwingt Speicherrecycling.

Das obige ist der detaillierte Inhalt vonAnalyse der Entwicklung des Garbage-Collection-Mechanismus in PHP5. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!