PHP-Kernel-Explorationsvariable Zval-PHP-Tutorial-php.cn

Wir wissen bereits, dass PHP-Variablen tatsächlich über die zval-Struktur im Kernel implementiert werden, und wir haben auch ein vorläufiges Verständnis dafür, wie man den Typ und den Wert einer zval-Struktur festlegt.

Beim Codieren hoffen wir, dass der im Kernel erstellte zval von Benutzern in Form von Variablen in der PHP-Sprache verwendet werden kann. Um diese Funktion zu realisieren, müssen wir zunächst einen zval erstellen. Am einfachsten ist es, einen ZVAL-Zeiger zu erstellen, dann einen Teil des Speichers zuzuweisen und den Zeiger darauf zeigen zu lassen. Wenn der Schatten von malloc(sizeof(zval)) in Ihrem Kopf auftaucht, hören Sie bitte sofort auf und verwenden Sie nicht malloc, um dies zu tun. Der Grund ist derselbe wie zuvor. Um den Code schön zu gestalten und die Kompatibilität bei Versionsaktualisierungen aufrechtzuerhalten. Dieses Makro ist: MAKE_STD_ZVAL(pzv). Dieses Makro verwendet die Kernel-Methode, um ein Stück Speicher zu beantragen, seine Adresse an pzv zu zahlen und seine beiden Attribute refcount und is_ref zu initialisieren. Was noch besser ist, ist, dass es nicht nur das Problem des unzureichenden Speichers automatisch behandelt, sondern auch auswählt Die Erinnerung im Gedächtnis. Der beste Ort, um sich zu bewerben.

Als Datencontainer müssen wir häufig mit Variablen umgehen, unabhängig davon, ob es sich bei den Variablen um Zahlen, Arrays, Zeichenfolgen, Objekte oder andere handelt. Daher kann man sagen, dass Variablen eine unverzichtbare Grundlage für die Sprache sind. Dieser Artikel ist der erste Artikel über Variablen, die im PHP-Kernel untersucht werden. Er stellt hauptsächlich die Grundkenntnisse von zval vor, einschließlich der folgenden Aspekte:

Grundstruktur von Zval
Methoden zum Anzeigen von zval: debug_zval_dump und xdebug
Zvals Prinzip, COW usw.

Aufgrund der Hektik des Schreibens kann es zwangsläufig zu Fehlern kommen, bitte weisen Sie darauf hin.

1. Grundstruktur von Zval

Zval ist eine der wichtigsten Datenstrukturen in PHP (eine weitere wichtige Datenstruktur ist die Hash-Tabelle), die Informationen über Variablenwerte und -typen in PHP enthält. Es handelt sich um eine Struktur, die Grundstruktur ist:

<span>struct</span><span> _zval_struct {
    zvalue_value value; </span><span>/*</span><span> value </span><span>*/</span><span> zend_uint refcount__gc; </span><span>/*</span><span> variable ref count </span><span>*/</span><span> zend_uchar type; </span><span>/*</span><span> active type </span><span>*/</span><span> zend_uchar is_ref__gc; </span><span>/*</span><span> if it is a ref variable </span><span>*/</span><span> };
typedef </span><span>struct</span> _zval_struct zval;

Nach dem Login kopieren

Unter ihnen:

1.zval_value-Wert

Der tatsächliche Wert der Variablen, insbesondere eine Vereinigung von zvalue_value:

<span>typedef union _zvalue_value { </span><span>long</span> lval; <span>/*</span><span> long value </span><span>*/</span> <span>double</span> dval; <span>/*</span><span> double value </span><span>*/</span> <span>struct</span> { <span>/*</span><span> string </span><span>*/</span> <span>char</span> *<span>val; </span><span>int</span><span> len;
    } str;
    HashTable </span>*ht; <span>/*</span><span> hash table value,used for array </span><span>*/</span><span> zend_object_value obj; </span><span>/*</span><span> object </span><span>*/</span><span> } zvalue_value;</span>

Nach dem Login kopieren

2. zend_uint refcount__gc

Dieser Wert ist eigentlich ein Zähler, um zu speichern, wie viele Variablen (oder Symbole, Symbole) Alle Symbole in der Symboltabelle gespeichert werden und verschiedene Bereiche unterschiedliche Symbole verwenden (wir werden dies später besprechen). ) zeigt auf den zval. Wenn die Variable generiert wird, ist ihr Refcount = 1. Typische Zuweisungsoperationen wie $a = $b erhöhen den Refcount von zval um 1, und die nicht gesetzte Operation verringert ihn entsprechend um 1. Vor PHP5.3 wurde der Referenzzählmechanismus zur Implementierung von GC verwendet. Wenn der Refcount eines zval kleiner als 0 war, ging die Zend-Engine davon aus, dass keine Variable auf den zval verweist, und gab daher den von ihm belegten Speicherplatz frei der Zval. Aber manchmal sind die Dinge nicht so einfach. Wir werden später sehen, dass der einfache Referenzzählmechanismus den zirkulär referenzierten zval nicht GC durchführen kann, selbst wenn die Variable, die auf den zval verweist, nicht gesetzt wurde, was zu einem Speicherverlust führt (Memory Leak).

3. zend_uchar-Typ

Dieses Feld wird verwendet, um den tatsächlichen Typ der Variablen anzugeben. Als wir anfingen, PHP zu lernen, wussten wir bereits, dass Variablen in PHP vier Skalartypen (bool, int, float, string), zwei zusammengesetzte Typen (Array, Objekt) und zwei spezielle Typen (Ressource und NULL). Innerhalb von Zend entsprechen diese Typen den folgenden Makros (Codespeicherort phpsrc/Zend/zend.h):

<span>#define</span> IS_NULL     0 <span>#define</span> IS_LONG     1 <span>#define</span> IS_DOUBLE   2 <span>#define</span> IS_BOOL     3 <span>#define</span> IS_ARRAY    4 <span>#define</span> IS_OBJECT   5 <span>#define</span> IS_STRING   6 <span>#define</span> IS_RESOURCE 7 <span>#define</span> IS_CONSTANT 8 <span>#define</span> IS_CONSTANT_ARRAY   9 <span>#define</span> IS_CALLABLE 10

Nach dem Login kopieren

4. is_ref__gc

In diesem Feld wird markiert, ob es sich bei der Variablen um eine Referenzvariable handelt. Für gewöhnliche Variablen ist der Wert 0 und für Referenzvariablen ist der Wert 1. Diese Variable wirkt sich auf die gemeinsame Nutzung, Trennung usw. von zval aus. Wir werden das später besprechen.

Wie der Name schon sagt, sind ref_count__gc und is_ref__gc zwei sehr wichtige Felder, die für den GC-Mechanismus von PHP erforderlich sind. Die Werte dieser beiden Felder können mit Debugging-Tools wie xdebug angezeigt werden.

2. xdebug-Installationskonfiguration

Xdebug ist ein Open-Source-PHP-Leistungsanalyse- und Debugging-Tool. Obwohl für das allgemeine Programm-Debugging gängige Debugging-Tools wie var_dump, echo, print und debug_backtrace grundsätzlich ausreichen, sind für einige komplexe Debugging- und Leistungstests jedoch xdebug ist definitiv ein guter Helfer (andere Tools wie Xhprof sind auch hervorragend).

Grundlegende Umgebung dieses Artikels:

Der grundlegende Prozess der Installation von Xdebug ist (eigentlich das Kompilieren einer Erweiterung aus dem Quellcode):

1. Laden Sie das Quellcodepaket herunter.

Die Download-Adresse lautet: http://www.xdebug.org/docs/install

　　本文中下载的版本为：Xdebug-2.6.tar.gz

2.　　解压

<span>tar</span> xvzf xdebug-<span>2.6</span>.<span>tar</span>.gz

Nach dem Login kopieren

3.　　在xdebug的目录执行phpize

4.　　./configure 配置

5.　　Make&& make install

这会生成xdebug.so扩展文件（zend_extension）,位置在xdebug/modules

6.　　在php.ini中加载xdebug扩展

zend_extension=your-xdebug-path/xdebug.so

Nach dem Login kopieren

7.　　添加xdebug的配置

xdebug.profiler_enable =<span> on
xdebug.default_enable </span>=<span> on
xdebug.trace_output_dir</span>="/tmp/xdebug"<span> xdebug.trace_output_name </span>=<span> trace.%c.%p
xdebug.profiler_output_dir</span>="/tmp/xdebug"<span> xdebug.profiler_output_name</span>="cachegrind.out.%s"

Nach dem Login kopieren

这里不再详细介绍各个配置项的含义，详细的请看：http://www.xdebug.org/docs/all

现在，PHP中，应该已经有了Xdebug的扩展信息（php –m，也可以phpinfo()）：

在Xdebug中，可以通过xdebug_debug_zval打印Zval的信息：

<?php
    $a = array( 'test' );
    $a[] = &$a;
    xdebug_debug_zval( 'a' );

Nach dem Login kopieren

3.　　Zval的更多原理

（注，本部分主要参考：http://derickrethans.nl/collecting-garbage-phps-take-on-variables.html，作者Derick Rethans是一位优秀的PHP内核专家，在全世界做过多次报告，都有相关的pdf下载，这里（http://derickrethans.nl/talks.html ）有作者每次演讲的记录，很多都值得我们深入去学习研究）

前面我们已经说过，PHP使用Zval这种结构来保存变量，这里我们将继续追踪zval的更多细节。

1. 创建变量时，会创建一个zval.

$str = "test zval";
xdebug_debug_zval('str');

Nach dem Login kopieren

输出结果：

str: (refcount=1, is_ref=0)='test zval'

Nach dem Login kopieren

当使用$str="test zval";来创建变量时，会在当前作用域的符号表中插入新的符号（str）,由于该变量是一个普通的变量，因此会生成一个refcount=1且is_ref=0的zval容器。也就是说，实际上是这样的:

2. 变量赋值给另外一个变量时，会增加zval的refcount值。

$str  = "test zval";
$str2 = $str;
xdebug_debug_zval('str');
xdebug_debug_zval('str2');

Nach dem Login kopieren

输出结果：

str: (refcount=2, is_ref=0)=<span>'test zval'
str2: (refcount</span>=2, is_ref=0)='test zval'

Nach dem Login kopieren

同时我们看到，str和是str2这两个symbol的zval结构是一样的。这里其实是PHP所做的一个优化，由于str和str2都是普通变量，因而它们指向了同一个zval，而没有为str2开辟单独的zval。这么做，可以在一定程度上节省内存。这时的str,str2与zval的对应关系是这样的：

3. 使用unset时，对减少相应zval的refcount值

$str  = "test zval";
$str3 = $str2 = $str;
xdebug_debug_zval('str');
unset($str2,$str3)
xdebug_debug_zval('str');

Nach dem Login kopieren

结果为：

str: (refcount=3, is_ref=0)=<span>'test zval'
str: (refcount</span>=1, is_ref=0)='test zval'

Nach dem Login kopieren

由于unset($str2,$str3)会将str2和str3从符号表中删除，因此，在unset之后，只有str指向该zval，如下图所示：

现在如果执行unset($str)，则由于zval的refcount会减少到0，该zval会从内存中清理。这当然是最理想的情况。

但是事情并不总是那么乐观。

4. 数组变量与普通变量生成的zval非常类似，单也有很大不同

与标量这些普通变量不同，数组和对象这类复合型的变量在生成zval时，会为每个item项生成一个zval容器。例如：

$ar = array(
    'id'   => 38,
    'name' => 'shine'
); <span>xdebug_debug_zval('ar');</span>

Nach dem Login kopieren

打印出zval的结构是：

ar: (refcount=1, is_ref=0)=<span>array (
    'id' </span>=> (refcount=1, is_ref=0)=38,<span> 'name' </span>=> (refcount=1, is_ref=0)=<span>'shine'
)</span>

Nach dem Login kopieren

如下图所示：

可以看出，变量$ar生成的过程中，共生成了3个zval容器（红色部分标注）。对于每个zval而言，refcount的增减规则与普通变量的相同。例如，我们在数组中添加另外一个元素，并把$ar['name']的值赋给它：

$ar = array(
    'id'   => 38,
    'name' => 'shine'
);

$ar['test'] = $ar['name'];
xdebug_debug_zval('ar');

Nach dem Login kopieren

则打印出的zval为：

ar: (refcount=1, is_ref=0)=<span>array (
    'id' </span>=> (refcount=1, is_ref=0)=38,<span> 'name' </span>=> (refcount=2, is_ref=0)='shine',<span> 'test' </span>=> (refcount=2, is_ref=0)=<span>'shine'
)</span>

Nach dem Login kopieren

如同普通变量一样，这时候,name和test这两个symbol指向同一个zval:

同样的，从数组中移除元素时，会从符号表中删除相应的符号，同时减少对应zval的refcount值。同样，如果zval的refcount值减少到0，那么就会从内存中删除该zval：

$ar = array(
    'id'   => 38,
    'name' => 'shine'
);

$ar['test'] = $ar['name'];
unset($ar['test'],$ar['name']);
xdebug_debug_zval('ar');

Nach dem Login kopieren

输出结果为：

ar: (refcount=1, is_ref=0)=array ('id' => (refcount=1, is_ref=0)=38)

Nach dem Login kopieren

5. 引用的出现，会令zval的规则变得复杂

在加入引用之后，情况会变的稍微复杂一点。例如，在数组中添加对本身的引用：

$a = $array('one');
$a[] = &$a;
xdebug_debug_zval('a');

Nach dem Login kopieren

输出的结果：

a: (refcount=2, is_ref=1)=<span>array ( </span>0 => (refcount=1, is_ref=0)='one', 
    1 => (refcount=2, is_ref=1)=<span>...
)</span>

Nach dem Login kopieren

上述输出中，…表示指向原始数组，因而这是一个循环的引用。如下图所示：

现在，我们对$a执行unset操作，这会在symbol table中删除相应的symbol,同时，zval的refcount减1（之前为2），也就是说，现在的zval应该是这样的结构：

(refcount=1, is_ref=1)=<span>array ( </span>0 => (refcount=1, is_ref=0)='one', 
    1 => (refcount=1, is_ref=1)=<span>...
)</span>

Nach dem Login kopieren

也就是下图所示的结构：

　　这时，不幸的事情发生了！

　　Unset之后，虽然没有变量指向该zval，但是该zval却不能被GC（指PHP5.3之前的单纯引用计数机制的GC）清理掉，因为zval的refcount均大于0。这样，这些zval实际上会一直存在内存中，直到请求结束（参考SAPI的生命周期）。在此之前，这些zval占据的内存不能被使用，便白白浪费了，换句话说，无法释放的内存导致了内存泄露。

　　如果这种内存泄露仅仅发生了一次或者少数几次，倒也还好，但如果是成千上万次的内存泄露，便是很大的问题了。尤其在长时间运行的脚本中（例如守护程序，一直在后台执行不会中断），由于无法回收内存，最终会导致系统“再无内存可用”。

6. zval分离（Copy on write和change on write）

前面我们已经介绍过，在变量赋值的过程中例如$b = $a，为了节省空间,并不会为$a和$b都开辟单独的zval，而是使用共享zval的形式：

那么问题来了：如果其中一个变量发生变化时，如何处理zval的共享问题？

对于这样的代码：

$a = "a simple test";
$b = $a;

echo "before write:".PHP_EOL;
xdebug_debug_zval('a');
xdebug_debug_zval('b');

$b = "thss";
echo "after write:".PHP_EOL;
xdebug_debug_zval('a');
xdebug_debug_zval('b');

Nach dem Login kopieren

打印的结果是：

<span>before write:
a: (refcount</span>=2, is_ref=0)=<span>'a simple test'
b: (refcount</span>=2, is_ref=0)=<span>'a simple test'
after write:
a: (refcount</span>=1, is_ref=0)=<span>'a simple test'
b: (refcount</span>=1, is_ref=0)='thss'

Nach dem Login kopieren

起初，符号表中a和b指向了同一个zval(这么做的原因是节省内存)，而后$b发生了变化，Zend会检查b指向的zval的refcount是否为1，如果是1，那么说明只有一个符号指向该zval，则直接更改zval。否则，说明这是一个共享的zval，需要将该zval分离出去，以保证单独变化互不影响，这种机制叫做COW –Copy on write。在很多场景下，COW都是一种比较高效的策略。

那么对于引用变量呢？

$a = 'test';
$b = &$a;

echo "before change:".PHP_EOL;
xdebug_debug_zval('a');
xdebug_debug_zval('b');

$b = 12;
echo "after change:".PHP_EOL;
xdebug_debug_zval('a');
xdebug_debug_zval('b');

unset($b);
echo "after unset:".PHP_EOL;
xdebug_debug_zval('a');
xdebug_debug_zval('b');

Nach dem Login kopieren

输出的结果为：

<span>before change:
a: (refcount</span>=2, is_ref=1)=<span>'test'
b: (refcount</span>=2, is_ref=1)=<span>'test'

after change:
a: (refcount</span>=2, is_ref=1)=12<span> b: (refcount</span>=2, is_ref=1)=12<span> after unset:
a: (refcount</span>=1, is_ref=0)=12

Nach dem Login kopieren

可以看出，在改变了$b的值之后，Zend会检查zval的is_ref检查是否是引用变量，如果是引用变量，则直接更改即可，否则，需要执行刚刚提到的zval分离。由于$a 和 $b是引用变量，因而更改共享的zval实际上也间接更改了$a的值。而在unset($b)之后，变量$b从符号表中删除了。

这里也说明一个问题，unset并不是清除zval，而只是从符号表中删除相应的symbol。这样一来，之前很多的关于引用的疑问也可以理解了（下一节我们将深入探索PHP的引用）。

以上就介绍了PHP内核探索之变量Zval，包括了变量Zval方面的内容，希望对PHP教程有兴趣的朋友有所帮助。