Explication détaillée de la structure zval et du mécanisme de comptage de références en PHP7

Étude recommandée : "Tutoriel vidéo PHP"

Récemment, alors que je vérifiais les informations sur le garbage collection PHP7, quelques exemples de code sur Internet ont été trouvés localement. Différents résultats se sont produits lors de l'exécution dans différents environnements, ce qui m'a rendu très confus. Si vous y réfléchissez bien, il n'est pas difficile de trouver le problème : la plupart de ces articles proviennent de PHP5. > Se concentre principalement sur l'explication du mécanisme de comptage de références dans le nouveau conteneur zval. n'hésitez pas à me donner quelques conseils.

La nouvelle structure zval en PHP7

Ne parlons pas en secret, regardons d'abord le code !

struct _zval_struct {
    union {
        zend_long         lval;             /* long value */
        double            dval;             /* double value */
        zend_refcounted  *counted;
        zend_string      *str;
        zend_array       *arr;
        zend_object      *obj;
        zend_resource    *res;
        zend_reference   *ref;
        zend_ast_ref     *ast;
        zval             *zv;
        void             *ptr;
        zend_class_entry *ce;
        zend_function    *func;
        struct {
            uint32_t w1;
            uint32_t w2;
        } ww;
    } value;
    union {
        struct {
            ZEND_ENDIAN_LOHI_4(
                zend_uchar    type,         /* active type */
                zend_uchar    type_flags,
                zend_uchar    const_flags,
                zend_uchar    reserved)     /* call info for EX(This) */
        } v;
        uint32_t type_info;
    } u1;
    union {
        uint32_t     var_flags;
        uint32_t     next;                 /* hash collision chain */
        uint32_t     cache_slot;           /* literal cache slot */
        uint32_t     lineno;               /* line number (for ast nodes) */
        uint32_t     num_args;             /* arguments number for EX(This) */
        uint32_t     fe_pos;               /* foreach position */
        uint32_t     fe_iter_idx;          /* foreach iterator index */
    } u2;
};
复制代码

Pour une description détaillée de cette structure, vous pouvez vous référer à l'article de frère Niao en fin d'article. Il est très détaillé, je ne vais pas en montrer aux autres. Ici, je n'en proposerai que quelques-uns. points clés :

• Les variables en PHP7 sont divisées en deux parties :

  nom de la variable et valeur de la variable, qui correspondent à et à la zval_structvalue y sont déclarés respectivement. Les

  et
dans

• zval_struct.valuezend_long sont tous deux des doubletypes de données simples, qui peuvent stocker directement des valeurs spécifiques, tandis que d'autres types de données complexes stockent un pointeur vers le pointeur d'une autre structure de données

• En PHP7, le compteur de référence est stocké dans

  au lieu de valuezval_struct

• NULL et Booléen appartiennent tous au type de données sans valeur (le type booléen est marqué par deux constantes et IS_FALSE), donc naturellement Il n'y a pas de décompte de références IS_TRUE

• La référence (REFERENCE) devient une structure de données au lieu d'un simple bit de marque. est la suivante :

struct _zend_reference {
    zend_refcounted_h gc;
    zval              val;
}

• , en tant que type zend_reference contenu dans zval_struct, a également sa propre valeur value, qui pointe à un val. Ils ont tous leur propre zval_struct.valuecompteur de références.

Le compteur de référence est utilisé pour enregistrer combien de

pointent actuellement vers le même zval. zend_value

Pour le sixième point, veuillez regarder le code suivant :

$a = 'foo';
$b = &$a;
$c = $a;

La structure des données à ce moment est la suivante :

$a et $b ont chacun un

conteneur , et les zval_struct qu'ils contiennent pointent tous vers la même value structure, zend_reference est intégré à une structure zend_reference, pointant vers la même val, et le contenu de la chaîne zend_string y est stocké.

Et $c a également un

, et sa valeur peut directement pointer vers le zval_struct mentionné ci-dessus lors de l'initialisation, de sorte qu'aucune copie ne se produira pendant la copie. zend_string

Parlons des différents phénomènes qui se produiront dans cette nouvelle

structure et des raisons derrière ces phénomènes. zval

Question

1. Pourquoi la valeur initiale du compteur de référence de certaines variables est 0

Phénomènes

$var_int = 233;
$var_float = 233.3;
$var_str = '233';

xdebug_debug_zval('var_int');
xdebug_debug_zval('var_float');
xdebug_debug_zval('var_str');

/** 输出 **
var_int:
(refcount=0, is_ref=0)int 233

var_float:
(refcount=0, is_ref=0)float 233.3

var_str:
(refcount=0, is_ref=0)string '233' (length=3)
**********/

Cause

En PHP7, lors de l'attribution d'une valeur à une variable, il y a deux parties de l'opération :

1 Demander une structure

pour la quantité symbolique (c'est-à-dire le nom de la variable) zval_struct2 , stocker la valeur de la variable dans

Pour les valeurs que

peut enregistrer dans le champ zval_struct.value, elles ne seront pas comptées en référence, zval mais directement attribuées lors de la copie. value, ces types incluent :

IS_LONG

• IS_DOUBLE
• , c'est-à-dire notre

mise en forme

et en PHP Float. Alors pourquoi le refcount de var_str est-il également 0 ?

Cela implique deux types de chaînes en PHP :

1,

Chaînes internes (noms de fonctions, noms de classes, noms de variables, chaînes statiques) :

 $str = '233';    // 静态字符串

interned string2. :

 $str = '233' . time();

Pour

chaîne interne

, le contenu de la chaîne est la seule constante, qui équivaut aux caractères définis dans la zone des variables statiques en langage C Strings, leur durée de vie Le cycle existe pendant toute la période de demande. Une fois la demande terminée, ils seront uniformément détruits et libérés . Naturellement, il n'est pas nécessaire d'effectuer une gestion de la mémoire par comptage de références.

二. 为什么在对整形、浮点型和静态字符串型变量进行引用赋值时，计数器的值会直接变为2

现象

$var_int_1 = 233;
$var_int_2 = &var_int;
xdebug_debug_zval('var_int_1');

/** 输出 **
var_int:
(refcount=2, is_ref=1)int 233
**********/

原因

回忆一下我们开头讲的 zval_struct 中 value 的数据结构，当为一个变量赋整形、浮点型或静态字符串类型的值时，value 的数据类型为 zend_long 、 double 或 zend_string，这时值是可以直接储存在 value 中的。而按值拷贝时，会开辟一个新的 zval_struct 以同样的方式将值储存到相同数据类型的 value 中，所以 refcount 的值一直都会为 0。

但是当使用 & 操作符进行引用拷贝时，情况就不一样了：

• PHP 为 & 操作符操作的变量申请一个 zend_reference 结构

• 将 zend_reference.value 指向原来的 zval_struct.value

• zval_struct.value 的数据类型会被修改为 zend_refrence

• 将 zval_struct.value 指向刚刚申请并初始化后的 zend_reference

• 为新变量申请 zval_struct 结构，将他的 value 指向刚刚创建的 zend_reference

此时：$var\_int\_1 和 $var_int_2 都拥有一个 zval_struct 结构体，并且他们的 zval_struct.value 都指向了同一个 zend_reference 结构，所以该结构的引用计数器的值为 2。

题外话：zend_reference 又指向了一个整形或浮点型的 value，如果指向的 value 类型是 zend_string，那么该 value 引用计数器的值为 1。而 xdebug 出来的 refcount 显示的是 zend_reference 的计数器值（即 2）

三. 为什么初始数组的引用计数器的值为 2

现象

$var_empty_arr = [1, 2, '3'];
xdebug_debug_zval('var_empty_arr');

/** 输出 **
var_arr:
(refcount=2, is_ref=0)
array (size=3)
  0 => (refcount=0, is_ref=0)int 1
  1 => (refcount=0, is_ref=0)int 2
  2 => (refcount=1, is_ref=0)string '3' (length=1)
**********/

原因

这牵扯到 PHP7 中的另一个概念，叫做 immutable array（不可变数组）。

For arrays the not-refcounted variant is called an "immutable array". If you use opcache, then constant array literals in your code will be converted into immutable arrays. Once again, these live in shared memory and as such must not use refcounting. Immutable arrays have a dummy refcount of 2, as it allows us to optimize certain separation paths.

不可变数组是 opcache 扩展优化出的一种数组类型，简单的说，所有多次编译结果恒定不变的数组，都会被优化为不可变数组，下面是一个反例：

$array = [1, 2, time()];

PHP 在编译阶段无法得知 time() 函数的返回值，所以此处的 $array 是可变数组。

不可变数组和我们上面讲到的内部字符串一样，都是不使用引用计数的，但是不同点是，内部字符串的计数值恒为 0，而不可变数组会使用一个伪计数值 2。

总结

• 简单数据类型

  • 整形（不使用引用计数）
  • 浮点型（不使用引用计数）
  • 布尔型（不使用引用计数）
  • NULL（不使用引用计数）

• 复杂数据类型

  • 字符串

    • 普通字符串（使用引用计数，初始值为 1）
    • 内部字符串（不使用引用计数，引用计数值恒为 0）

  • 数组

    • 普通数组（使用引用计数，初始值为 1）
    • 不可变数组（不使用引用计数，使用伪计数值 2）
  • 对象（使用引用计数，初始值为 1）

更多编程相关知识，请访问：编程视频！！

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!