详谈PHP垃圾回收机制

谁借莪１个温暖的怀抱￠ 2022-05-21 05:38 184阅读 0赞

**引用计数基本知识**

每个php变量存在一个叫"zval"的变量容器中。一个zval变量容器，除了包含变量的类型和值，还包括两个字节的额外信息。第一个是"is\_ref"，是个bool值，用来标识这个变量是否是属于引用集合(reference set)。通过这个字节，php引擎才能把普通变量和引用变量区分开来，由于php允许用户通过使用&来使用自定义引用，zval变量容器中还有一个内部引用计数机制，来优化内存使用。第二个额外字节是"refcount"，用以表示指向这个zval变量容器的变量(也称符号即symbol)个数。所有的符号存在一个符号表中，其中每个符号都有作用域(scope)，那些主脚本(比如：通过浏览器请求的的脚本)和每个函数或者方法也都有作用域。

当一个变量被赋常量值时，就会生成一个zval变量容器，如下例这样：

**Example \#1 生成一个新的zval容器**

<?php

$a  =  "new string" ;

在上例中，新的变量 *a*，是在当前作用域中生成的。并且生成了类型为 [string][] 和值为 *new string*的变量容器。在额外的两个字节信息中，"is\_ref"被默认设置为 **FALSE**，因为没有任何自定义的引用生成。"refcount" 被设定为 *1*，因为这里只有一个变量使用这个变量容器. 注意到当"refcount"的值是 *1*时，"is\_ref"的值总是 **FALSE**. 如果你已经安装了 [» Xdebug][Xdebug]，你能通过调用函数 **xdebug\_debug\_zval()**显示"refcount"和"is\_ref"的值。

**Example \#2 显示zval信息**

<?php

xdebug\_debug\_zval ( 'a' );

以上例程会输出：

a: (refcount=1, is\_ref=0)='new string'

把一个变量赋值给另一变量将增加引用次数(refcount).

**Example \#3 增加一个zval的引用计数**

<?php

$a  =  "new string" ;

$b  =  $a ;

xdebug\_debug\_zval (  'a'  );

以上例程会输出：

a: (refcount=2, is\_ref=0)='new string'

这时，引用次数是 *2*，因为同一个变量容器被变量 *a* 和变量  *b*关联.当没必要时，php不会去复制已生成的变量容器。变量容器在”refcount“变成0时就被销毁. 当任何关联到某个变量容器的变量离开它的作用域(比如：函数执行结束)，或者对变量调用了函数 [unset()][unset]时，”refcount“就会减1，下面的例子就能说明:

**Example \#4 减少引用计数**

<?php

$a  =  "new string" ;

$c  =  $b  =  $a ;

xdebug\_debug\_zval (  'a'  );

unset(  $b ,  $c  );

xdebug\_debug\_zval (  'a'  );

以上例程会输出：

a: (refcount=3, is\_ref=0)='new string'a: (refcount=1, is\_ref=0)='new string'

如果我们现在执行  *unset($a);*，包含类型和值的这个变量容器就会从内存中删除。

**复合类型(Compound Types)**

当考虑像  [array][]和 [object][]这样的复合类型时，事情就稍微有点复杂. 与 标量(scalar)类型的值不同， [array][]和 [object][]类型的变量把它们的成员或属性存在自己的符号表中。这意味着下面的例子将生成三个zval变量容器。

**Example \#5 Creating a** [**array**][array] ** zval**

<?php

$a  = array(  'meaning'  =>  'life' ,  'number'  =>  42  );

xdebug\_debug\_zval (  'a'  );

以上例程的输出类似于：

a: (refcount=1, is\_ref=0)=array ( 'meaning' => (refcount=1, is\_ref=0)='life', 'number' => (refcount=1, is\_ref=0)=42)

图示:

上面的结果如果在PHP5中是没有问题的，但是当我在PHP7中进行试验验证是发现输出的结果和上面并不一致，如下：

*(refcount=1, is\_ref=0)* **array** *(size=2)* 'meaning'  =>  *(refcount=2, is\_ref=0)*string  'life'  *(length=4)* 'number'  =>  *(refcount=0, is\_ref=0)*int  42

这三个zval变量容器是: *a*， *meaning*和 *number*。增加和减少”refcount”的规则和上面提到的一样. 下面, 我们在数组中再添加一个元素,并且把它的值设为数组中已存在元素的值:

**Example \#6 添加一个已经存在的元素到数组中**

<?php

$a  = array(  'meaning'  =>  'life' ,  'number'  =>  42  );

$a \[ 'life' \] =  $a \[ 'meaning' \];

xdebug\_debug\_zval (  'a'  );

以上例程的输出类似于：

a: (refcount=1, is\_ref=0)=array ( 'meaning' => (refcount=2, is\_ref=0)='life', 'number' => (refcount=1, is\_ref=0)=42, 'life' => (refcount=2, is\_ref=0)='life')

PHP7中的运行结果

*(refcount=1, is\_ref=0)* **array** *(size=3)* 'meaning'  =>  *(refcount=3, is\_ref=0)*string  'life'  *(length=4)* 'number'  =>  *(refcount=0, is\_ref=0)*int  42 'life'  =>  *(refcount=3, is\_ref=0)*string  'life'  *(length=4)*

图示：

从以上的xdebug输出信息，我们看到原有的数组元素和新添加的数组元素关联到同一个"refcount" *2*的zval变量容器. 尽管 Xdebug的输出显示两个值为 *'life'*的 zval 变量容器，其实是同一个。 函数 **xdebug\_debug\_zval()**不显示这个信息，但是你能通过显示内存指针信息来看到。

删除数组中的一个元素，就是类似于从作用域中删除一个变量. 删除后,数组中的这个元素所在的容器的“refcount”值减少，同样，当“refcount”为0时，这个变量容器就从内存中被删除，下面又一个例子可以说明：

**Example \#7 从数组中删除一个元素**

<?php

$a  = array(  'meaning'  =>  'life' ,  'number'  =>  42  );

$a \[ 'life' \] =  $a \[ 'meaning' \];

unset(  $a \[ 'meaning' \],  $a \[ 'number' \] );

xdebug\_debug\_zval (  'a'  );

以上例程的输出类似于：

a: (refcount=1, is\_ref=0)=array ( 'life' => (refcount=1, is\_ref=0)='life')

PHP7中运行的结果

*(refcount=1, is\_ref=0)* **array** *(size=1)* 'life'  =>  *(refcount=2, is\_ref=0)*string  'life'  *(length=4)*

现在，当我们添加一个数组本身作为这个数组的元素时，事情就变得有趣，下个例子将说明这个。例中我们加入了引用操作符，否则php将生成一个复制。

**Example \#8 把数组作为一个元素添加到自己**

<?php

$a  = array(  'one'  );

$a \[\] =&  $a ;

xdebug\_debug\_zval (  'a'  );

以上例程的输出类似于：

a: (refcount=2, is\_ref=1)=array ( 0 => (refcount=1, is\_ref=0)='one', 1 => (refcount=2, is\_ref=1)=...)

PHP中运行的结果

*(refcount=2, is\_ref=1)* **array** *(size=2)* 0  => *(refcount=2, is\_ref=0)*string  'one'  *(length=3)* 1  =>  *(refcount=2, is\_ref=1)*  *&* **array<**

图示：

能看到数组变量 ( *a*) 同时也是这个数组的第二个元素( *1*) 指向的变量容器中“refcount”为 *2*。上面的输出结果中的"..."说明发生了递归操作, 显然在这种情况下意味着"..."指向原始数组。

跟刚刚一样，对一个变量调用unset，将删除这个符号，且它指向的变量容器中的引用次数也减1。所以，如果我们在执行完上面的代码后，对变量 *$a*调用unset, 那么变量 *$a* 和数组元素 "1" 所指向的变量容器的引用次数减1, 从"2"变成"1". 下例可以说明:

**Example \#9 Unsetting** ***$a***

(refcount=1, is\_ref=1)=array ( 0 => (refcount=1, is\_ref=0)='one', 1 => (refcount=1, is\_ref=1)=...)

图示：

**通过PHP5和PHP7环境中的运行结果对比可以看出，PHP7中的内存回收机制有了改变，那么为什么会有这种改变呢？我查阅了一些资料供大家参考。**

**PHP7 中的 zval**

在 PHP7 中 zval 有了新的实现方式。最基础的变化就是 zval 需要的内存不再是单独从堆上分配，不再自己存储引用计数。复杂数据类型（比如字符串、数组和对象）的引用计数由其自身来存储。这种实现方式有以下好处：

简单数据类型不需要单独分配内存，也不需要计数；

不会再有两次计数的情况。在对象中，只有对象自身存储的计数是有效的；

由于现在计数由数值自身存储，所以也就可以和非 zval 结构的数据共享，比如 zval 和 hashtable key 之间；

间接访问需要的指针数减少了。

我们看看现在 zval 结构体的定义（现在在 zend\_types.h 文件中）：

struct \_zval\_struct \{

zend\_value  value;   /\* 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;

\};

结构体的第一个元素没太大变化，仍然是一个 value 联合体。第二个成员是由一个表示类型信息的整型和一个包含四个字符变量的结构体组成的联合体（可以忽略 ZEND\_ENDIAN\_LOHI\_4 宏，它只是用来解决跨平台大小端问题的）。这个子结构中比较重要的部分是 type（和以前类似）和 type\_flags，这个接下来会解释。

上面这个地方也有一点小问题：value 本来应该占 8 个字节，但是由于内存对齐，哪怕只增加一个字节，实际上也是占用 16 个字节（使用一个字节就意味着需要额外的 8 个字节）。但是显然我们并不需要 8 个字节来存储一个 type 字段，所以我们在 u1 的后面增加了了一个名为 u2 的联合体。默认情况下是用不到的，需要使用的时候可以用来存储 4 个字节的数据。这个联合体可以满足不同场景下的需求。

**PHP7 中 value 的结构定义如下：**

typedef union \_zend\_value \{

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;

\} zend\_value;

首先需要注意的是现在 value 联合体需要的内存是 8 个字节而不是 16。它只会直接存储整型（lval）或者浮点型（dval）数据，其他情况下都是指针（上面提到过，指针占用 8 个字节，最下面的结构体由两个 4 字节的无符号整型组成）。上面所有的指针类型（除了特殊标记的）都有一个同样的头（zend\_refcounted）用来存储引用计数：

typedef struct \_zend\_refcounted\_h \{

uint32\_t   refcount;   /\* reference counter 32-bit \*/

union \{

struct \{

ZEND\_ENDIAN\_LOHI\_3(

zend\_uchar type,

zend\_uchar flags, /\* used for strings & objects \*/

uint16\_t  gc\_info) /\* keeps GC root number (or 0) and color \*/

\} v;

uint32\_t type\_info;

\} u;

\} zend\_refcounted\_h;

现在，这个结构体肯定会包含一个存储引用计数的字段。除此之外还有 type、flags 和 gc\_info。type 存储的和 zval 中的 type 相同的内容，这样 GC 在不存储 zval 的情况下单独使用引用计数。flags 在不同的数据类型中有不同的用途，这个放到下一部分讲。

gc\_info 和 PHP5 中的 buffered 作用相同，不过不再是位于根缓冲区的指针，而是一个索引数字。因为以前根缓冲区的大小是固定的（10000 个元素），所以使用一个 16 位（2 字节）的数字代替 64 位（8 字节）的指针足够了。gc\_info 中同样包含一个『颜色』位用于回收时标记结点。

**zval 内存管理**

上文提到过 zval 需要的内存不再单独从堆上分配。但是显然总要有地方来存储它，所以会存在哪里呢？实际上大多时候它还是位于堆中（所以前文中提到的地方重点不是堆，而是单独分配），只不过是嵌入到其他的数据结构中的，比如 hashtable 和 bucket 现在就会直接有一个 zval 字段而不是指针。所以函数表编译变量和对象属性在存储时会是一个 zval 数组并得到一整块内存而不是散落在各处的 zval 指针。之前的 zval \* 现在都变成了 zval。

之前当 zval 在一个新的地方使用时会复制一份 zval \* 并增加一次引用计数。现在就直接复制 zval 的值（忽略 u2），某些情况下可能会增加其结构指针指向的引用计数（如果在进行计数）。

那么 PHP 怎么知道 zval 是否正在计数呢？不是所有的数据类型都能知道，因为有些类型（比如字符串或数组）并不是总需要进行引用计数。所以 type\_info 字段就是用来记录 zval 是否在进行计数的，这个字段的值有以下几种情况：

\#define IS\_TYPE\_CONSTANT   (1<<0) /\* special \*/

\#define IS\_TYPE\_IMMUTABLE   (1<<1) /\* special \*/

\#define IS\_TYPE\_REFCOUNTED   (1<<2)

\#define IS\_TYPE\_COLLECTABLE   (1<<3)

\#define IS\_TYPE\_COPYABLE   (1<<4)

\#define IS\_TYPE\_SYMBOLTABLE   (1<<5) /\* special \*/

注：在 7.0.0 的正式版本中，上面这一段宏定义的注释这几个宏是供 zval.u1.v.type\_flags 使用的。这应该是注释的错误，因为这个上述字段是 zend\_uchar 类型。

type\_info 的三个主要的属性就是『可计数』（refcounted）、『可回收』（collectable）和『可复制』（copyable）。计数的问题上面已经提过了。『可回收』用于标记 zval 是否参与循环，不如字符串通常是可计数的，但是你却没办法给字符串制造一个循环引用的情况。

是否可复制用于表示在复制时是否需要在复制时制造（原文用的 "duplication" 来表述，用中文表达出来可能不是很好理解）一份一模一样的实体。"duplication" 属于深度复制，比如在复制数组时，不仅仅是简单增加数组的引用计数，而是制造一份全新值一样的数组。但是某些类型（比如对象和资源）即使 "duplication" 也只能是增加引用计数，这种就属于不可复制的类型。这也和对象和资源现有的语义匹配（现有，PHP7 也是这样，不单是 PHP5）。

下面的表格上标明了不同的类型会使用哪些标记（x 标记的都是有的特性）。『简单类型』（simple types）指的是整型或布尔类型这些不使用指针指向一个结构体的类型。下表中也有『不可变』（immutable）的标记，它用来标记不可变数组的，这个在下一部分再详述。

interned string（保留字符）在这之前没有提过，其实就是函数名、变量名等无需计数、不可重复的字符串。

| refcounted | collectable | copyable | immutable

\----------------+------------+-------------+----------+----------

simple types    |            |             |          |

string          |      x     |             |     x    |

interned string |            |             |          |

array           |      x     |      x      |     x    |

immutable array |            |             |          |     x

object          |      x     |      x      |          |

resource        |      x     |             |          |

reference       |      x     |             |          |

要理解这一点，我们可以来看几个例子，这样可以更好的认识 zval 内存管理是怎么工作的。

下面是整数行为模式，在上文中 PHP5 的例子的基础上进行了一些简化 ：

<?php

$a = 42; // $a = zval\_1(type=IS\_LONG, value=42)

$b = $a; // $a = zval\_1(type=IS\_LONG, value=42)

// $b = zval\_2(type=IS\_LONG, value=42)

$a \+= 1; // $a = zval\_1(type=IS\_LONG, value=43)

// $b = zval\_2(type=IS\_LONG, value=42)

unset($a); // $a = zval\_1(type=IS\_UNDEF)

// $b = zval\_2(type=IS\_LONG, value=42)

这个过程其实挺简单的。现在整数不再是共享的，变量直接就会分离成两个单独的 zval，由于现在 zval 是内嵌的所以也不需要单独分配内存，所以这里的注释中使用 = 来表示的而不是指针符号 ->，unset 时变量会被标记为 IS\_UNDEF。下面看一下更复杂的情况：

<?php

$a = \[\]; // $a = zval\_1(type=IS\_ARRAY) -> zend\_array\_1(refcount=1, value=\[\])

$b = $a; // $a = zval\_1(type=IS\_ARRAY) -> zend\_array\_1(refcount=2, value=\[\])

// $b = zval\_2(type=IS\_ARRAY) ---^

// zval 分离在这里进行

$a\[\] = 1 // $a = zval\_1(type=IS\_ARRAY) -> zend\_array\_2(refcount=1, value=\[1\])

// $b = zval\_2(type=IS\_ARRAY) -> zend\_array\_1(refcount=1, value=\[\])

unset($a); // $a = zval\_1(type=IS\_UNDEF), zend\_array\_2 被销毁

// $b = zval\_2(type=IS\_ARRAY) -> zend\_array\_1(refcount=1, value=\[\])

这种情况下每个变量变量有一个单独的 zval，但是是指向同一个（有引用计数） zend\_array 的结构体。修改其中一个数组的值时才会进行复制。这点和 PHP5 的情况类似。

**类型（Types）**

我们大概看一下 PHP7 支持哪些类型（zval 使用的类型标记）：

/\* regular data types \*/

\#define IS\_UNDEF     0

\#define IS\_NULL      1

\#define IS\_FALSE     2

\#define IS\_TRUE      3

\#define IS\_LONG      4

\#define IS\_DOUBLE     5

\#define IS\_STRING     6

\#define IS\_ARRAY     7

\#define IS\_OBJECT     8

\#define IS\_RESOURCE     9

\#define IS\_REFERENCE    10

/\* constant expressions \*/

\#define IS\_CONSTANT     11

\#define IS\_CONSTANT\_AST    12

/\* internal types \*/

\#define IS\_INDIRECT     15

\#define IS\_PTR      17

**这个列表和 PHP5 使用的类似，不过增加了几项：**

IS\_UNDEF 用来标记之前为 NULL 的 zval 指针（和 IS\_NULL 并不冲突）。比如在上面的例子中使用 unset 注销变量；

IS\_BOOL 现在分割成了 IS\_FALSE 和 IS\_TRUE 两项。现在布尔类型的标记是直接记录到 type 中，这么做可以优化类型检查。不过这个变化对用户是透明的，还是只有一个『布尔』类型的数据（PHP 脚本中）。

PHP 引用不再使用 is\_ref 来标记，而是使用 IS\_REFERENCE 类型。这个也要放到下一部分讲；

IS\_INDIRECT  和  IS\_PTR 是特殊的内部标记。

实际上上面的列表中应该还存在两个 fake types，这里忽略了。

IS\_LONG 类型表示的是一个 zend\_long 的值，而不是原生的 C 语言的 long 类型。原因是 Windows 的 64 位系统（LLP64）上的 long 类型只有 32 位的位深度。所以 PHP5 在 Windows 上只能使用 32 位的数字。PHP7 允许你在 64 位的操作系统上使用 64 位的数字，即使是在 Windows 上面也可以。

zend\_refcounted 的内容会在下一部分讲。下面看看 PHP 引用的实现。

**引用**

PHP7 使用了和 PHP5 中完全不同的方法来处理 PHP & 符号引用的问题（这个改动也是 PHP7 开发过程中大量 bug 的根源）。我们先从 PHP5 中 PHP 引用的实现方式说起。

通常情况下， 写时复制原则意味着当你修改一个 zval 之前需要对其进行分离来保证始终修改的只是某一个 PHP 变量的值。这就是传值调用的含义。

但是使用 PHP 引用时这条规则就不适用了。如果一个 PHP 变量是 PHP 引用，就意味着你想要在将多个 PHP 变量指向同一个值。PHP5 中的 is\_ref 标记就是用来注明一个 PHP 变量是不是 PHP 引用，在修改时需不需要进行分离的。比如：

<?php

$a = \[\]; // $a  -> zval\_1(type=IS\_ARRAY, refcount=1, is\_ref=0) -> HashTable\_1(value=\[\])

$b =& $a; // $a, $b -> zval\_1(type=IS\_ARRAY, refcount=2, is\_ref=1) -> HashTable\_1(value=\[\])

$b\[\] = 1; // $a = $b = zval\_1(type=IS\_ARRAY, refcount=2, is\_ref=1) -> HashTable\_1(value=\[1\])

// 因为 is\_ref 的值是 1, 所以 PHP 不会对 zval 进行分离

但是这个设计的一个很大的问题在于它无法在一个 PHP 引用变量和 PHP 非引用变量之间共享同一个值。比如下面这种情况：

<?php

$a = \[\]; // $a   -> zval\_1(type=IS\_ARRAY, refcount=1, is\_ref=0) -> HashTable\_1(value=\[\])

$b = $a; // $a, $b  -> zval\_1(type=IS\_ARRAY, refcount=2, is\_ref=0) -> HashTable\_1(value=\[\])

$c = $b  // $a, $b, $c -> zval\_1(type=IS\_ARRAY, refcount=3, is\_ref=0) -> HashTable\_1(value=\[\])

$d =& $c; // $a, $b -> zval\_1(type=IS\_ARRAY, refcount=2, is\_ref=0) -> HashTable\_1(value=\[\])

// $c, $d -> zval\_1(type=IS\_ARRAY, refcount=2, is\_ref=1) -> HashTable\_2(value=\[\])

// $d 是 $c 的引用, 但却不是 $a 的 $b, 所以这里 zval 还是需要进行复制

// 这样我们就有了两个 zval, 一个 is\_ref 的值是 0, 一个 is\_ref 的值是 1.

$d\[\] = 1; // $a, $b -> zval\_1(type=IS\_ARRAY, refcount=2, is\_ref=0) -> HashTable\_1(value=\[\])

// $c, $d -> zval\_1(type=IS\_ARRAY, refcount=2, is\_ref=1) -> HashTable\_2(value=\[1\])

// 因为有两个分离了的 zval, $d\[\] = 1 的语句就不会修改 $a 和 $b 的值.

这种行为方式也导致在 PHP 中使用引用比普通的值要慢。比如下面这个例子：

<?php

$array = range(0, 1000000);

$ref =& $array;

var\_dump(count($array)); // <-- 这里会进行分离

因为 count() 只接受传值调用，但是 $array 是一个 PHP 引用，所以 count() 在执行之前实际上会有一个对数组进行完整的复制的过程。如果 $array 不是引用，这种情况就不会发生了。

现在我们来看看 PHP7 中 PHP 引用的实现。因为 zval 不再单独分配内存，也就没办法再使用和 PHP5 中相同的实现了。所以增加了一个 IS\_REFERENCE 类型，并且专门使用 zend\_reference 来存储引用值：

struct \_zend\_reference \{

zend\_refcounted gc;

zval    val;

\};

本质上 zend\_reference 只是增加了引用计数的 zval。所有引用变量都会存储一个 zval 指针并且被标记为 IS\_REFERENCE。val 和其他的 zval 的行为一样，尤其是它也可以在共享其所存储的复杂变量的指针，比如数组可以在引用变量和值变量之间共享。

我们还是看例子，这次是 PHP7 中的语义。为了简洁明了这里不再单独写出 zval，只展示它们指向的结构体：

<?php

$a = \[\]; // $a          -> zend\_array\_1(refcount=1, value=\[\])

$b =& $a; // $a, $b -> zend\_reference\_1(refcount=2) -> zend\_array\_1(refcount=1, value=\[\])

$b\[\] = 1; // $a, $b -> zend\_reference\_1(refcount=2) -> zend\_array\_1(refcount=1, value=\[1\])

上面的例子中进行引用传递时会创建一个 zend\_reference，注意它的引用计数是 2（因为有两个变量在使用这个 PHP 引用）。但是值本身的引用计数是 1（因为 zend\_reference 只是有一个指针指向它）。下面看看引用和非引用混合的情况：

<?php

$a = \[\]; // $a   -> zend\_array\_1(refcount=1, value=\[\])

$b = $a; // $a, $b, -> zend\_array\_1(refcount=2, value=\[\])

$c = $b  // $a, $b, $c -> zend\_array\_1(refcount=3, value=\[\])

$d =& $c; // $a, $b         -> zend\_array\_1(refcount=3, value=\[\])

// $c, $d -> zend\_reference\_1(refcount=2) ---^

// 注意所有变量共享同一个 zend\_array, 即使有的是 PHP 引用有的不是

$d\[\] = 1; // $a, $b         -> zend\_array\_1(refcount=2, value=\[\])

// $c, $d -> zend\_reference\_1(refcount=2) -> zend\_array\_2(refcount=1, value=\[1\])

// 只有在这时进行赋值的时候才会对 zend\_array 进行赋值

这里和 PHP5 最大的不同就是所有的变量都可以共享同一个数组，即使有的是 PHP 引用有的不是。只有当其中某一部分被修改的时候才会对数组进行分离。这也意味着使用 count() 时即使给其传递一个很大的引用数组也是安全的，不会再进行复制。不过引用仍然会比普通的数值慢，因为存在需要为 zend\_reference 结构体分配内存（间接）并且引擎本身处理这一块儿也不快的的原因。

**结语**

总结一下 PHP7 中最重要的改变就是 zval 不再单独从堆上分配内存并且不自己存储引用计数。需要使用 zval 指针的复杂类型（比如字符串、数组和对象）会自己存储引用计数。这样就可以有更少的内存分配操作、更少的间接指针使用以及更少的内存分配。

**清理变量容器的问题(Cleanup Problems)**

尽管不再有某个作用域中的任何符号指向这个结构(就是变量容器)，由于数组元素“1”仍然指向数组本身，所以这个容器不能被清除 。因为没有另外的符号指向它，用户没有办法清除这个结构，结果就会导致内存泄漏。庆幸的是，php将在脚本执行结束时清除这个数据结构，但是在php清除之前，将耗费不少内存。如果你要实现分析算法，或者要做其他像一个子元素指向它的父元素这样的事情，这种情况就会经常发生。当然，同样的情况也会发生在对象上，实际上对象更有可能出现这种情况，因为对象总是隐式的被引用。

如果上面的情况发生仅仅一两次倒没什么，但是如果出现几千次，甚至几十万次的内存泄漏，这显然是个大问题。这样的问题往往发生在长时间运行的脚本中，比如请求基本上不会结束的守护进程(deamons)或者单元测试中的大的套件(sets)中。后者的例子：在给巨大的eZ(一个知名的PHP Library) 组件库的模板组件做单元测试时，就可能会出现问题。有时测试可能需要耗用2GB的内存，而测试服务器很可能没有这么大的内存。

**回收周期(Collecting Cycles)**

传统上，像以前的 php 用到的引用计数内存机制，无法处理循环的引用内存泄漏。然而 5.3.0 PHP 使用文章 [» 引用计数系统中的同步周期回收(Concurrent Cycle Collection in Reference Counted Systems)][Concurrent Cycle Collection in Reference Counted Systems]中的同步算法，来处理这个内存泄漏问题。

对算法的完全说明有点超出这部分内容的范围，将只介绍其中基础部分。首先，我们先要建立一些基本规则，如果一个引用计数增加，它将继续被使用，当然就不再在垃圾中。如果引用计数减少到零，所在变量容器将被清除(free)。就是说，仅仅在引用计数减少到非零值时，才会产生垃圾周期(garbage cycle)。其次，在一个垃圾周期中，通过检查引用计数是否减1，并且检查哪些变量容器的引用次数是零，来发现哪部分是垃圾。

为避免不得不检查所有引用计数可能减少的垃圾周期，这个算法把所有可能根(possible roots 都是zval变量容器),放在根缓冲区(root buffer)中(用紫色来标记，称为疑似垃圾)，这样可以同时确保每个可能的垃圾根(possible garbage root)在缓冲区中只出现一次。仅仅在根缓冲区满了时，才对缓冲区内部所有不同的变量容器执行垃圾回收操作。看上图的步骤 A。

在步骤 B 中，模拟删除每个紫色变量。模拟删除时可能将不是紫色的普通变量引用数减"1"，如果某个普通变量引用计数变成0了，就对这个普通变量再做一次模拟删除。每个变量只能被模拟删除一次，模拟删除后标记为灰（原文说确保不会对同一个变量容器减两次"1",不对的吧）。

在步骤 C 中，模拟恢复每个紫色变量。恢复是有条件的，当变量的引用计数大于0时才对其做模拟恢复。同样每个变量只能恢复一次，恢复后标记为黑，基本就是步骤 B 的逆运算。这样剩下的一堆没能恢复的就是该删除的蓝色节点了，在步骤 D 中遍历出来真的删除掉。

算法中都是模拟删除、模拟恢复、真的删除，都使用简单的遍历即可（最典型的深搜遍历）。复杂度为执行模拟操作的节点数正相关，不只是紫色的那些疑似垃圾变量。

现在，你已经对这个算法有了基本了解，我们回头来看这个如何与PHP集成。默认的，PHP的垃圾回收机制是打开的，然后有个 *php.ini* 设置允许你修改它： **zend.enable\_gc** 。

当垃圾回收机制打开时，每当根缓存区存满时，就会执行上面描述的循环查找算法。根缓存区有固定的大小，可存10,000个可能根,当然你可以通过修改PHP源码文件 *Zend/zend\_gc.c*中的常量 *GC\_ROOT\_BUFFER\_MAX\_ENTRIES*，然后重新编译PHP，来修改这个10,000值。当垃圾回收机制关闭时，循环查找算法永不执行，然而，可能根将一直存在根缓冲区中，不管在配置中垃圾回收机制是否激活。

当垃圾回收机制关闭时，如果根缓冲区存满了可能根，更多的可能根显然不会被记录。那些没被记录的可能根，将不会被这个算法来分析处理。如果他们是循环引用周期的一部分，将永不能被清除进而导致内存泄漏。

即使在垃圾回收机制不可用时，可能根也被记录的原因是，相对于每次找到可能根后检查垃圾回收机制是否打开而言，记录可能根的操作更快。不过垃圾回收和分析机制本身要耗不少时间。

除了修改配置 **zend.enable\_gc** ，也能通过分别调用 [gc\_enable()][gc_enable] 和  [gc\_disable()][gc_disable]函数来打开和关闭垃圾回收机制。调用这些函数，与修改配置项来打开或关闭垃圾回收机制的效果是一样的。即使在可能根缓冲区还没满时，也能强制执行周期回收。你能调用 [gc\_collect\_cycles()][gc_collect_cycles]函数达到这个目的。这个函数将返回使用这个算法回收的周期数。

允许打开和关闭垃圾回收机制并且允许自主的初始化的原因，是由于你的应用程序的某部分可能是高时效性的。在这种情况下，你可能不想使用垃圾回收机制。当然，对你的应用程序的某部分关闭垃圾回收机制，是在冒着可能内存泄漏的风险，因为一些可能根也许存不进有限的根缓冲区。因此，就在你调用 [gc\_disable()][gc_disable]函数释放内存之前，先调用 [gc\_collect\_cycles()][gc_collect_cycles]函数可能比较明智。因为这将清除已存放在根缓冲区中的所有可能根，然后在垃圾回收机制被关闭时，可留下空缓冲区以有更多空间存储可能根。

参考文献：

https://blog.csdn.net/wangshiqueque/article/details/78074363

[string]: http://php.net/manual/zh/language.types.string.php
[Xdebug]: http://xdebug.org/
[unset]: http://php.net/manual/zh/function.unset.php
[array]: http://php.net/manual/zh/language.types.array.php
[object]: http://php.net/manual/zh/language.types.object.php
[Concurrent Cycle Collection in Reference Counted Systems]: http://researcher.watson.ibm.com/researcher/files/us-bacon/Bacon01Concurrent.pdf
[gc_enable]: http://php.net/manual/zh/function.gc-enable.php
[gc_disable]: http://php.net/manual/zh/function.gc-disable.php
[gc_collect_cycles]: http://php.net/manual/zh/function.gc-collect-cycles.php