PHP新的垃圾回收機制:Zend GC詳解

時間 2019-11-12

標籤 php 新的垃圾回收機制 zend 詳解欄目 PHP 简体版

原文原文鏈接

概述php

在5.2及更早版本的PHP中，沒有專門的垃圾回收器GC（Garbage Collection），引擎在判斷一個變量空間是否可以被釋放的時候是依據這個變量的zval的refcount的值，若是refcount爲0，那麼變量的空間能夠被釋放，不然就不釋放，這是一種很是簡單的GC實現。然而在這種簡單的GC實現方案中，出現了意想不到的變量內存泄漏狀況（Bug:http://bugs.php.net/bug.php?id=33595），引擎將沒法回收這些內存，因而在PHP5.3中出現了新的GC，新的GC有專門的機制負責清理垃圾數據，防止內存泄漏。本文將詳細的闡述PHP5.3中新的GC運行機制。c++

目前不多有詳細的資料介紹新的GC，本文將是目前國內最爲詳細的從源碼角度介紹PHP5.3中GC原理的文章。其中關於垃圾產生以及算法簡介部分由筆者根據手冊翻譯而來，固然其中融入了本人的一些見解。手冊中相關內容：Garbage Collectionweb

在介紹這個新的GC以前，讀者必須先了解PHP中變量的內部存儲相關知識，請先閱讀變量的內部存儲：引用和計數算法

什麼算垃圾數組

首先咱們須要定義一下「垃圾」的概念，新的GC負責清理的垃圾是指變量的容器zval還存在，可是又沒有任何變量名指向此zval。所以GC判斷是否爲垃圾的一個重要標準是有沒有變量名指向變量容器zval。函數

假設咱們有一段PHP代碼，使用了一個臨時變量$tmp存儲了一個字符串，在處理完字符串以後，就不須要這個$tmp變量了，$tmp變量對於咱們來講能夠算是一個「垃圾」了，可是對於GC來講，$tmp其實並非一個垃圾，$tmp變量對咱們沒有意義，可是這個變量實際還存在，$tmp符號依然指向它所對應的zval，GC會認爲PHP代碼中可能還會使用到此變量，因此不會將其定義爲垃圾。性能

那麼若是咱們在PHP代碼中使用完$tmp後，調用unset刪除這個變量，那麼$tmp是否是就成爲一個垃圾了呢。很惋惜，GC仍然不認爲$tmp是一個垃圾，由於$tmp在unset以後，refcount減小1變成了0(這裏假設沒有別的變量和$tmp指向相同的zval),這個時候GC會直接將$tmp對應的zval的內存空間釋放，$tmp和其對應的zval就根本不存在了。此時的$tmp也不是新的GC所要對付的那種「垃圾」。那麼新的GC究竟要對付什麼樣的垃圾呢，下面咱們將生產一個這樣的垃圾。測試

頑固垃圾的產生過程ui

若是讀者已經閱讀了變量內部存儲相關的內容，想必對refcount和isref這些變量內部的信息有了必定的瞭解。這裏咱們將結合手冊中的一個例子來介紹垃圾的產生過程：url

<?php

$a = "new string";

在這麼簡單的一個代碼中，$a變量內部存儲信息爲

a: (refcount=1, is_ref=0)='new string'

當把$a賦值給另一個變量的時候，$a對應的zval的refcount會加1

<?php

$a = "new string";

$b = $a;

?>
此時$a和$b變量對應的內部存儲信息爲

a,b: (refcount=2, is_ref=0)='new string'

當咱們用unset刪除$b變量的時候，$b對應的zval的refcount會減小1

<?php

$a = "new string"; //a: (refcount=1, is_ref=0)='new string'

$b = $a; //a,b: (refcount=2, is_ref=0)='new string'

unset($b); //a: (refcount=1, is_ref=0)='new string'

對於普通的變量來講，這一切彷佛很正常，可是在複合類型變量（數組和對象）中，會發生比較有意思的事情：

<?php

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

a的內部存儲信息爲:

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

數組變量自己($a)在引擎內部其實是一個哈希表，這張表中有兩個zval項 meaning和number，

因此實際上那一行代碼中一共生成了3個zval,這3個zval都遵循變量的引用和計數原則，用圖來表示:

下面在$a中添加一個元素，並將現有的一個元素的值賦給新的元素:

<?php

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

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

那麼$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'
)
其中的meaning元素和life元素之指向同一個zval的：

如今，若是咱們試一下，將數組的引用賦值給數組中的一個元素，有意思的事情就發生了：

<?php

$a = array('one');

$a[] = &$a;

這樣$a數組就有兩個元素，一個索引爲0，值爲字符one,另一個索引爲1，爲$a自身的引用，內部存儲以下:

a: (refcount=2, is_ref=1)=array (
0 => (refcount=1, is_ref=0)='one',
1 => (refcount=2, is_ref=1)=…
)

「…」表示1指向a自身，是一個環形引用：

這個時候咱們對$a進行unset,那麼$a會從符號表中刪除，同時$a指向的zval的refcount減小1

<?php

$a = array('one');

$a[] = &$a;

unset($a);

那麼問題也就產生了，$a已經不在符號表中了，用戶沒法再訪問此變量，可是$a以前指向的zval的refcount變爲1而不是0，所以不能被回收，這樣產生了內存泄露：

這樣，這麼一個zval就成爲了一個真是意義的垃圾了，新的GC要作的工做就是清理這種垃圾。

爲解決這種垃圾，產生了新的GC

在PHP5.3版本中，使用了專門GC機制清理垃圾，在以前的版本中是沒有專門的GC，那麼垃圾產生的時候，沒有辦法清理，內存就白白浪費掉了。在PHP5.3源代碼中多瞭如下文件:{PHPSRC}/Zend/zend_gc.h {PHPSRC}/Zend/zend_gc.c, 這裏就是新的GC的實現，咱們先簡單的介紹一下算法思路，而後再從源碼的角度詳細介紹引擎中如何實現這個算法的。

新的GC算法

在較新的PHP手冊中有簡單的介紹新的GC使用的垃圾清理算法，這個算法名爲 Concurrent Cycle Collection in Reference Counted Systems ，這裏不詳細介紹此算法，根據手冊中的內容來先簡單的介紹一下思路：

首先咱們有幾個基本的準則：

1：若是一個zval的refcount增長，那麼此zval還在使用，不屬於垃圾

2：若是一個zval的refcount減小到0，那麼zval能夠被釋放掉，不屬於垃圾

3：若是一個zval的refcount減小以後大於0，那麼此zval還不能被釋放，此zval可能成爲一個垃圾

只有在準則3下，GC纔會把zval收集起來，而後經過新的算法來判斷此zval是否爲垃圾。那麼如何判斷這麼一個變量是否爲真正的垃圾呢？

簡單的說，就是對此zval中的每一個元素進行一次refcount減1操做，操做完成以後，若是zval的refcount=0，那麼這個zval就是一個垃圾。這個原理咋看起來很簡單，可是又不是那麼容易理解，起初筆者也沒法理解其含義，直到挖掘了源代碼以後纔算是瞭解。若是你如今不理解沒有關係，後面會詳細介紹，這裏先把這算法的幾個步驟描敘一下,首先引用手冊中的一張圖:

A：爲了不每次變量的refcount減小的時候都調用GC的算法進行垃圾判斷，此算法會先把全部前面準則3狀況下的zval節點放入一個節點(root)緩衝區(root buffer)，而且將這些zval節點標記成紫色，同時算法必須確保每個zval節點在緩衝區中之出現一次。當緩衝區被節點塞滿的時候，GC纔開始開始對緩衝區中的zval節點進行垃圾判斷。

B：當緩衝區滿了以後，算法以深度優先對每個節點所包含的zval進行減1操做，爲了確保不會對同一個zval的refcount重複執行減1操做，一旦zval的refcount減1以後會將zval標記成灰色。須要強調的是，這個步驟中，起初節點zval自己不作減1操做，可是若是節點zval中包含的zval又指向了節點zval（環形引用），那麼這個時候須要對節點zval進行減1操做。

C：算法再次以深度優先判斷每個節點包含的zval的值，若是zval的refcount等於0，那麼將其標記成白色(表明垃圾)，若是zval的refcount大於0，那麼將對此zval以及其包含的zval進行refcount加1操做，這個是對非垃圾的還原操做，同時將這些zval的顏色變成黑色（zval的默認顏色屬性）

D：遍歷zval節點，將C中標記成白色的節點zval釋放掉。

這ABCD四個過程是手冊中對這個算法的介紹，這還不是那麼容易理解其中的原理，這個算法究竟是個什麼意思呢？我本身的理解是這樣的：

好比仍是前面那個變成垃圾的數組$a對應的zval,命名爲zval_a, 若是沒有執行unset， zval_a的refcount爲2,分別由$a和$a中的索引1指向這個zval。用算法對這個數組中的全部元素（索引0和索引1）的zval的refcount進行減1操做，因爲索引1對應的就是zval_a，因此這個時候zval_a的refcount應該變成了1，這樣zval_a就不是一個垃圾。若是執行了unset操做，zval_a的refcount就是1，由zval_a中的索引1指向zval_a,用算法對數組中的全部元素（索引0和索引1）的zval的refcount進行減1操做，這樣zval_a的refcount就會變成0，因而就發現zval_a是一個垃圾了。算法就這樣發現了頑固的垃圾數據。

舉了這個例子，讀者大概應該可以知道其中的端倪：

對於一個包含環形引用的數組，對數組中包含的每一個元素的zval進行減1操做，以後若是發現數組自身的zval的refcount變成了0，那麼能夠判斷這個數組是一個垃圾。

這個道理其實很簡單，假設數組a的refcount等於m, a中有n個元素又指向a,若是m等於n,那麼算法的結果是m減n，m-n=0，那麼a就是垃圾，若是m>n,那麼算法的結果m-n>0,因此a就不是垃圾了

m=n表明什麼？表明a的refcount都來自數組a自身包含的zval元素,表明a以外沒有任何變量指向它，表明用戶代碼空間中沒法再訪問到a所對應的zval，表明a是泄漏的內存，所以GC將a這個垃圾回收了。

PHP中運用新的GC的算法

在PHP中，GC默認是開啓的，你能夠經過ini文件中的 zend.enable_gc 項來開啓或則關閉GC。當GC開啓的時候，垃圾分析算法將在節點緩衝區(roots buffer)滿了以後啓動。緩衝區默承認以放10,000個節點，固然你也能夠經過修改Zend/zend_gc.c中的GC_ROOT_BUFFER_MAX_ENTRIES 來改變這個數值，須要從新編譯連接PHP。當GC關閉的時候，垃圾分析算法就不會運行，可是相關節點還會被放入節點緩衝區，這個時候若是緩衝區節點已經放滿，那麼新的節點就不會被記錄下來，這些沒有被記錄下來的節點就永遠也不會被垃圾分析算法分析。若是這些節點中有循環引用，那麼有可能產生內存泄漏。之因此在GC關閉的時候還要記錄這些節點，是由於簡單的記錄這些節點比在每次產生節點的時候判斷GC是否開啓更快，另外GC是能夠在腳本運行中開啓的，因此記錄下這些節點，在代碼運行的某個時候若是又開啓了GC，這些節點就能被分析算法分析。固然垃圾分析算法是一個比較耗時的操做。

在PHP代碼中咱們能夠經過gc_enable()和gc_disable()函數來開啓和關閉GC，也能夠經過調用gc_collect_cycles()在節點緩衝區未滿的狀況下強制執行垃圾分析算法。這樣用戶就能夠在程序的某些部分關閉或則開啓GC，也可強制進行垃圾分析算法。

新的GC算法的性能

1.防止泄漏節省內存

新的GC算法的目的就是爲了防止循環引用的變量引發的內存泄漏問題，在PHP中GC算法，當節點緩衝區滿了以後，垃圾分析算法會啓動，而且會釋放掉髮現的垃圾，從而回收內存，在PHP手冊上給了一段代碼和內存使用情況圖：

<?php class Foo { public $var = '3.1415962654'; }

$baseMemory = memory_get_usage();

for ( $i = 0; $i <= 100000; $i++ ) { $a = new Foo; $a->self = $a; if ( $i % 500 === 0 ) { echo sprintf( '%8d: ', $i ), memory_get_usage() - $baseMemory, "/n"; } } ?>

這段代碼的循環體中，新建了一個對象變量，而且用對象的一個成員指向了本身，這樣就造成了一個循環引用，當進入下一次循環的時候，又一次給對象變量從新賦值，這樣會致使以前的對象變量內存泄漏，在這個例子裏面有兩個變量泄漏了，一個是對象自己，另一個是對象中的成員self，可是這兩個變量只有對象會做爲垃圾收集器的節點被放入緩衝區(由於從新賦值至關於對它進行了unset操做，知足前面的準則3)。在這裏咱們進行了100,000次循環，而GC在緩衝區中有10,000節點的時候會啓動垃圾分析算法，因此這裏一共會進行10次的垃圾分析算法。從圖中能夠清晰的看到，在5.3版本PHP中，每次GC的垃圾分析算法被觸發後，內存會有一個明顯的減小。而在5.2版本的PHP中，內存使用量會一直增長。

2：運行效率影響

啓用了新的GC後，垃圾分析算法將是一個比較耗時的操做，手冊中給了一段測試代碼：

<?php class Foo { public $var = '3.1415962654'; }

for ( $i = 0; $i <= 1000000; $i++ )
{
$a = new Foo;
$a->self = $a;
}

echo memory_get_peak_usage(), "/n"; ?>

而後分別在GC開啓和關閉的狀況下執行這段代碼：

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

最終在該機器上，第一次執行大概使用10.7秒，第二次執行大概使用11.4秒，性能大約下降7%,不過內存的使用量下降了98%,從931M下降到了10M。固然這並非一個比較科學的測試方法，可是也能說明必定的問題。這種代碼測試的是一種極端惡劣條件，實際代碼中，特別是在WEB的應用中，很難出現大量循環引用，GC的分析算法的啓動不會這麼頻繁，小規模的代碼中甚至不多有機會啓動GC分析算法。

總結：

當GC的垃圾分析算法執行的時候，PHP腳本的效率會受到必定的影響，可是小規模的代碼通常不會有這個機會運行這個算法。若是一旦腳本中GC分析算法開始運行了，那麼將花費少許的時間節省出來了大量的內存，是一件很是划算的事情。新的GC對一些長期運行的PHP腳本效果更好，好比PHP的DAEMON守護進程，或則PHP-GTK進程等等。

引擎內部GC的實現

前面已經介紹了新的GC的基本原理以及性能相關的內容，其中一些都是在手冊中有簡單介紹了，那麼這裏咱們將從源代碼的角度來分析一下PHP如何實現新的GC。

1.zval的變化

在文件Zend/zend_gc.h中，從新定義了分配一個zval結構的宏:

[cpp] view plain copy

#undef ALLOC_ZVAL
#define ALLOC_ZVAL(z) /
do { /
(z) = (zval*)emalloc(sizeof(zval_gc_info)); /
GC_ZVAL_INIT(z); /
} while (0)

ALLOC_ZVAL的原始定義是在Zend/zend_alloc.h中，原始的定義只是分配一個zval結構的內存空間，而後在新的GC使用後，分配一個zval空間其實是分配了一個zval_gc_info結構的空間，下面看看zval_gc_info結構定義:

[cpp] view plain copy

typedef struct _zval_gc_info {
zval z;
union {
gc_root_buffer *buffered;
struct _zval_gc_info *next;
} u;
} zval_gc_info;

zval_gc_info這個結構的第一個成員就是一個zval結構，第二個成員是一個聯合體u，是一個指向gc_root_buffer的指針和一個指向_zval_gc_info的指針。第一個成員爲zval結構，這就保證了對zval_gc_info類型指針作類型轉換後和zval等價。在ALLOC_ZVAL宏中，分配了一個zval_gc_info的空間後，是將空間的指針轉換成了(zval *)。這樣就至關於分配了一個zval的空間。而後GC_ZVAL_INIT宏會把zval_gc_info中的成員u的buffered字段設置成NULL:

[cpp] view plain copy

#define GC_ZVAL_INIT(z) /
((zval_gc_info*)(z))->u.buffered = NULL

這個u.buffered指針就是用來表示這個zval對應的節點信息指針。

新的GC會爲全部的zval分配一個空間存放節點信息指針，只有當zval被GC放入節點緩衝區的時候，節點信息指針纔會被指向一個節點信息結構，不然節點信息指針一直是NULL。

具體方式是經過分配一個zval_gc_info結構來實現，這個結構包含了zval和節點信息指針buffered。

2.節點信息

zval的節點信息指針buffered指向一個gc_root_buffer類型，這個類型的定義以下:

[cpp] view plain copy

typedef struct _gc_root_buffer {
struct _gc_root_buffer *prev; /* double-linked list */
struct _gc_root_buffer *next;
zend_object_handle handle; /* must be 0 for zval */
union {
zval *pz;
zend_object_handlers *handlers;
} u;
} gc_root_buffer;

這是一個雙鏈表的節點結構類型，prev和next用來指向前一個節點和後一個節點，handel是和對象相關的，對象類型的變量比較特殊，咱們這裏不討論，u是一個聯合體，u.pz用來指向這個節點所對應的zval結構。這樣每個zval結構和zval對應的節點信息互相被關聯在一塊兒了:

經過一個zval指針pz找到節點指針: pr = ((zval_gc_info *)pz)->u.buffered

經過一個節點指針pr找到zval指針: pz = pr->u.pz

3.爲zval設置節點信息以及節點顏色信息

這裏GC應用了一些小技巧，先看看下面相關的宏:

[cpp] view plain copy

#define GC_COLOR 0x03
#define GC_BLACK 0x00
#define GC_WHITE 0x01
#define GC_GREY 0x02
#define GC_PURPLE 0x03
#define GC_ADDRESS(v) /
((gc_root_buffer*)(((zend_uintptr_t)(v)) & ~GC_COLOR))
#define GC_SET_ADDRESS(v, a) /
(v) = ((gc_root_buffer*)((((zend_uintptr_t)(v)) & GC_COLOR) | ((zend_uintptr_t)(a))))
#define GC_GET_COLOR(v) /
(((zend_uintptr_t)(v)) & GC_COLOR)
#define GC_SET_COLOR(v, c) /
(v) = ((gc_root_buffer*)((((zend_uintptr_t)(v)) & ~GC_COLOR) | (c)))
#define GC_SET_BLACK(v) /
(v) = ((gc_root_buffer*)(((zend_uintptr_t)(v)) & ~GC_COLOR))
#define GC_SET_PURPLE(v) /
(v) = ((gc_root_buffer*)(((zend_uintptr_t)(v)) | GC_PURPLE))
#define GC_ZVAL_INIT(z) /
((zval_gc_info*)(z))->u.buffered = NULL
#define GC_ZVAL_ADDRESS(v) /
GC_ADDRESS(((zval_gc_info*)(v))->u.buffered)
#define GC_ZVAL_SET_ADDRESS(v, a) /
GC_SET_ADDRESS(((zval_gc_info*)(v))->u.buffered, (a))
#define GC_ZVAL_GET_COLOR(v) /
GC_GET_COLOR(((zval_gc_info*)(v))->u.buffered)
#define GC_ZVAL_SET_COLOR(v, c) /
GC_SET_COLOR(((zval_gc_info*)(v))->u.buffered, (c))
#define GC_ZVAL_SET_BLACK(v) /
GC_SET_BLACK(((zval_gc_info*)(v))->u.buffered)
#define GC_ZVAL_SET_PURPLE(v) /
GC_SET_PURPLE(((zval_gc_info*)(v))->u.buffered)

其中宏GC_ZVAL_SET_ADDRESS(v, a)是爲v這個zval設置節點信息的指針a，這個宏先獲得v中的節點信息指針字段u.buffered，而後調用GC_ADDRESS(v,a)宏，將u.buffered字段設置成指針a。

GC_ADDRESS(v, a)宏的功能是將地址a賦給v，可是它的實現很奇怪:

(v) = ((gc_root_buffer*)((((zend_uintptr_t)(v)) & GC_COLOR) | ((zend_uintptr_t)(a))))

爲何須要這麼一個複雜的過程，並且設置指針值爲什麼還要牽扯到GC_COLOR顏色這個宏？

這裏就得先說說節點的顏色信息保存方式。

在前面GC的算法簡介中，提到了須要爲節點上色，而實際在咱們節點結構gc_root_buffer中並無哪個字段用來標識節點的顏色，這裏GC運用了一個小的技巧：利用節點指針的低兩位來標識顏色屬性。可能讀者會有疑問，用指針中的位來保存顏色屬性，那麼設置顏色後，指針不就變化了嗎，那麼還能查找到指針對應的結構嗎？這個還真能查到！爲何？這個和malloc分配的內存地址屬性有必定的關係，glib的malloc分配的內存地址都會有必定的對齊，這個對齊值爲2 * SIZE_SZ,在不一樣位的機器上這個值是不同的，可是能夠確保的是分配出來的指針的最低兩位確定是0，而後看看顏色相關的宏，GC_COLOR爲0x03, 3只須要兩個二進制位就可以保存，因此拿指針的最低兩位來保存顏色值是沒有任何問題的，可是在使用指針的時候必定要先把指針最低的兩位還原成0，不然指針指向的值是錯誤的。

這樣咱們就能理解爲何GC_ADDRESS須要這麼複雜了。由於v中的低2位保存了v的顏色信息，若是直接把a賦給v會覆蓋掉顏色信息，經過((zend_uintptr_t)(v)) & GC_COLOR能夠保留低兩位的顏色信息，同時其它的位都變成了0，將這個結果同a進行"|"操做，就能將a的賦給v,同時保留了v的顏色信息。

知道了顏色信息的存儲方式，那麼就應該很容易理解如何設置和獲取顏色信息，這裏就很少介紹了。

4.節點緩衝區

GC會將收集到的節點存放到一個緩衝區中，緩衝區滿的時候就開始進行垃圾分析算法。這個緩衝區實際上放在一個全局的結構中：

[cpp] view plain copy

typedef struct _zend_gc_globals {
zend_bool gc_enabled;
zend_bool gc_active;
gc_root_buffer *buf; /* preallocated arrays of buffers */
gc_root_buffer roots; /* list of possible roots of cycles */
gc_root_buffer *unused; /* list of unused buffers */
gc_root_buffer *first_unused; /* pointer to first unused buffer */
gc_root_buffer *last_unused; /* pointer to last unused buffer */
zval_gc_info *zval_to_free; /* temporaryt list of zvals to free */
zval_gc_info *free_list;
zval_gc_info *next_to_free;
zend_uint gc_runs;
zend_uint collected;
#if GC_BENCH
zend_uint root_buf_length;
zend_uint root_buf_peak;
zend_uint zval_possible_root;
zend_uint zobj_possible_root;
zend_uint zval_buffered;
zend_uint zobj_buffered;
zend_uint zval_remove_from_buffer;
zend_uint zobj_remove_from_buffer;
zend_uint zval_marked_grey;
zend_uint zobj_marked_grey;
#endif
} zend_gc_globals;

用宏GC_G(v)能夠訪問結構中的v字段。

簡單的介紹這個結構中幾個重要的字段的含義:

zend_bool gc_enabled:

是否開啓GC

zend_bool gc_active:

GC是否正在進行垃圾分析

gc_root_buffer *buf：

節點緩衝區指針，在GC初始化的時候，會分配10,000個gc_root_buffer結構的空間，buf爲第1個節點的地址

gc_root_buffer roots;

GC每次開始垃圾分析算法的時候，都是從這個節點開始進行(注意不是直接在緩衝區中按順序來分析節點，緩衝區值是存放節點信息內容，roots是分析的節點入口，是一個雙鏈表的入口)

其餘節點和垃圾分析過程當中的一些臨時數據有關，這裏暫不介紹。

5.GC的初始化

[cpp] view plain copy

ZEND_API void gc_init(TSRMLS_D)
{
if (GC_G(buf) == NULL && GC_G(gc_enabled)) {
GC_G(buf) = (gc_root_buffer*) malloc(sizeof(gc_root_buffer) * GC_ROOT_BUFFER_MAX_ENTRIES);
GC_G(last_unused) = &GC_G(buf)[GC_ROOT_BUFFER_MAX_ENTRIES];
gc_reset(TSRMLS_C);
}
}

首先在初始化以前會有一個全局變量

extern ZEND_API zend_gc_globals gc_globals;

在整個GC運行期間都依賴這個全局變量結構。

初始化是調用的gc_init函數，若是緩衝區指針字段爲空而且GC開啓，那麼就分配緩衝區，而後調用gc_reset初始化全局結構gc_globals中的相關字段。

6.節點放入緩衝區的時機

那麼如今就是一個比較關鍵的一步了，GC什麼時候爲zval設置節點信息，並將節點信息設置放入緩衝區等待分析處理。從前面介紹的GC算法的原理中，準則3：「若是一個zval的refcount減小以後大於0，那麼此zval還不能被釋放，此zval可能成爲一個垃圾」。咱們大概能夠知道當一個zval的refcount減小的時候，GC有可能爲zval分配節點並放入緩衝區。那麼在什麼狀況下zval的refcount會減小。在咱們調用unset的時候，會從當前符號的哈希表中刪除變量名對應的項，並對該項調用一個析構函數，因此這個refcount減小的操做發生在這個析構函數中。經過創建變量符號哈希表的代碼段能夠知道這個析構函數是什麼。這個析構函數最終的實如今Zend/zend_execute_API.c中：

[cpp] view plain copy

ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
{
#if DEBUG_ZEND>=2
printf("Reducing refcount for %x (%x): %d->%d/n", *zval_ptr, zval_ptr, Z_REFCOUNT_PP(zval_ptr), Z_REFCOUNT_PP(zval_ptr) – 1);
#endif
Z_DELREF_PP(zval_ptr);
if (Z_REFCOUNT_PP(zval_ptr) == 0) {
TSRMLS_FETCH();
if (*zval_ptr != &EG(uninitialized_zval)) {
GC_REMOVE_ZVAL_FROM_BUFFER(*zval_ptr);
zval_dtor(*zval_ptr);
efree_rel(*zval_ptr);
}
} else {
TSRMLS_FETCH();
if (Z_REFCOUNT_PP(zval_ptr) == 1) {
Z_UNSET_ISREF_PP(zval_ptr);
}
GC_ZVAL_CHECK_POSSIBLE_ROOT(*zval_ptr);
}
}

這個函數中：

Z_DELREF_PP(zval_ptr) ：對zval的refcount減1，減1以後

1.若是zval的refcount等於0,根據前面的準則2，這個變量的空間能夠直接被釋放掉，在釋放以前須要注意，有可能這個變量在以前已經被放入了節點緩衝區，因此須要調用GC_REMOVE_ZVAL_FROM_BUFFER(*zval_ptr)從節點緩衝區中刪除相關節點信息，而後調用zval_dtor和efree_rel釋放掉變量zval中變量佔用的空間和zval結構自身的空間。

2.若是zval的refcount等於1,根據前面的準則3，這個變量有可能會成爲一個垃圾，因而調用GC_ZVAL_CHECK_POSSIBLE_ROOT(*zval_ptr)爲其設置節點信息並放入緩衝區

所以，最終是經過GC_ZVAL_CHECK_POSSIBLE_ROOT宏來產生節點並放入緩衝等待處理，相關的宏和函數代碼爲：

[cpp] view plain copy

#define GC_ZVAL_CHECK_POSSIBLE_ROOT(z) /
gc_zval_check_possible_root((z) TSRMLS_CC)
static zend_always_inline void gc_zval_check_possible_root(zval *z TSRMLS_DC)
{
if (z->type == IS_ARRAY || z->type == IS_OBJECT) {
gc_zval_possible_root(z TSRMLS_CC);
}
}
ZEND_API void gc_zval_possible_root(zval *zv TSRMLS_DC)
{
if (UNEXPECTED(GC_G(free_list) != NULL &&
GC_ZVAL_ADDRESS(zv) != NULL &&
GC_ZVAL_GET_COLOR(zv) == GC_BLACK) &&
(GC_ZVAL_ADDRESS(zv) < GC_G(buf) ||
GC_ZVAL_ADDRESS(zv) >= GC_G(last_unused))) {
/* The given zval is a garbage that is going to be deleted by
* currently running GC */
return;
}
if (zv->type == IS_OBJECT) {
GC_ZOBJ_CHECK_POSSIBLE_ROOT(zv);
return;
}
GC_BENCH_INC(zval_possible_root);
if (GC_ZVAL_GET_COLOR(zv) != GC_PURPLE) {
GC_ZVAL_SET_PURPLE(zv);
if (!GC_ZVAL_ADDRESS(zv)) {
gc_root_buffer *newRoot = GC_G(unused);
if (newRoot) {
GC_G(unused) = newRoot->prev;
} else if (GC_G(first_unused) != GC_G(last_unused)) {
newRoot = GC_G(first_unused);
GC_G(first_unused)++;
} else {
if (!GC_G(gc_enabled)) {
GC_ZVAL_SET_BLACK(zv);
return;
}
zv->refcount__gc++;
gc_collect_cycles(TSRMLS_C);
zv->refcount__gc–;
newRoot = GC_G(unused);
if (!newRoot) {
return;
}
GC_ZVAL_SET_PURPLE(zv);
GC_G(unused) = newRoot->prev;
}
newRoot->next = GC_G(roots).next;
newRoot->prev = &GC_G(roots);
GC_G(roots).next->prev = newRoot;
GC_G(roots).next = newRoot;
GC_ZVAL_SET_ADDRESS(zv, newRoot);
newRoot->handle = 0;
newRoot->u.pz = zv;
GC_BENCH_INC(zval_buffered);
GC_BENCH_INC(root_buf_length);
GC_BENCH_PEAK(root_buf_peak, root_buf_length);
}
}
}

內聯函數gc_zval_check_possible_root會先判斷zval的類型，若是是數組或則對象類型纔有可能給zval分配節點信息並放入緩衝區。只有這兩種類型纔可能產生環形引用。雖然GC直接處理對象是數組和對象類型，可是在這些數組和對象中包含的任何類型變量都在GC的職責範圍以內，這個內聯函數最終掉用的是gc_zval_possible_root函數，下面重點分析此函數中的主要流程：

1：

if (UNEXPECTED(GC_G(free_list) != NULL &&
                GC_ZVAL_ADDRESS(zv) != NULL &&
             GC_ZVAL_GET_COLOR(zv) == GC_BLACK) &&
             (GC_ZVAL_ADDRESS(zv) < GC_G(buf) ||
              GC_ZVAL_ADDRESS(zv) >= GC_G(last_unused))) {
  /* The given zval is a garbage that is going to be deleted by
   * currently running GC */
  return;
}

首先檢查zval節點信息是否已經放入到節點緩衝區，若是已經放入到節點緩衝區，則直接返回，這樣保證節點緩衝區中的每一個zval節點只出現一次。

2：

if (zv->type == IS_OBJECT) {
GC_ZOBJ_CHECK_POSSIBLE_ROOT(zv);
return;
}

若是zval是對象類型，則走對象類型相關的流程，本文只以數組類型爲例講解，因此這個流程不闡述，讀者能夠觸類旁通。

if (GC_ZVAL_GET_COLOR(zv) != GC_PURPLE) {
GC_ZVAL_SET_PURPLE(zv);

…

}

若是zval沒有被標記爲紫色，就將其標記爲紫色，表示zval被放入到節點緩衝，不然不作後面的操做。

若是zval的節點信息指針爲空，則須要爲zval分配一個gc_root_buffer節點信息。這以後會有一些判斷機制，若是發現節點緩衝區已經滿了說明須要啓動垃圾分析流程了，垃圾分析流程在函數gc_collect_cycles(TSRMLS_C); 若是緩衝區沒有滿，則不會進入垃圾分析流程，爲zval分配的節點信息會被加入到GC_G(roots)爲入口的雙鏈表中。

從這個函數咱們發現了垃圾分析算法是當發現緩衝區滿的時候就當即觸發，垃圾分析跟代碼執行流是同步過程，也就是隻有垃圾分析結束以後，代碼纔會繼續執行。因此在咱們的PHP代碼中，若是某個unset正好使GC的節點緩衝區滿，觸發了垃圾分析流程，那麼這個unset耗費的時間將比通常的unset多不少。

gc_collect_cycles函數是真正的垃圾分析流程，這個函數定義爲:

[cpp] view plain copy

ZEND_API int gc_collect_cycles(TSRMLS_D)
{
int count = 0;
if (GC_G(roots).next != &GC_G(roots)) {
zval_gc_info *p, *q, *orig_free_list, *orig_next_to_free;
if (GC_G(gc_active)) {
return 0;
}
GC_G(gc_runs)++;
GC_G(zval_to_free) = FREE_LIST_END;
GC_G(gc_active) = 1;
gc_mark_roots(TSRMLS_C);
gc_scan_roots(TSRMLS_C);
gc_collect_roots(TSRMLS_C);
orig_free_list = GC_G(free_list);
orig_next_to_free = GC_G(next_to_free);
p = GC_G(free_list) = GC_G(zval_to_free);
GC_G(zval_to_free) = NULL;
GC_G(gc_active) = 0;
/* First call destructors */
while (p != FREE_LIST_END) {
if (Z_TYPE(p->z) == IS_OBJECT) {
if (EG(objects_store).object_buckets &&
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].valid &&
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount <= 0 &&
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.dtor &&
!EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].destructor_called) {
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].destructor_called = 1;
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount++;
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.dtor(EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.object, Z_OBJ_HANDLE(p->z) TSRMLS_CC);
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount–;
}
}
count++;
p = p->u.next;
}
/* Destroy zvals */
p = GC_G(free_list);
while (p != FREE_LIST_END) {
GC_G(next_to_free) = p->u.next;
if (Z_TYPE(p->z) == IS_OBJECT) {
if (EG(objects_store).object_buckets &&
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].valid &&
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount <= 0) {
EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount = 1;
Z_TYPE(p->z) = IS_NULL;
zend_objects_store_del_ref_by_handle_ex(Z_OBJ_HANDLE(p->z), Z_OBJ_HT(p->z) TSRMLS_CC);
}
} else if (Z_TYPE(p->z) == IS_ARRAY) {
Z_TYPE(p->z) = IS_NULL;
zend_hash_destroy(Z_ARRVAL(p->z));
FREE_HASHTABLE(Z_ARRVAL(p->z));
} else {
zval_dtor(&p->z);
Z_TYPE(p->z) = IS_NULL;
}
p = GC_G(next_to_free);
}
/* Free zvals */
p = GC_G(free_list);
while (p != FREE_LIST_END) {
q = p->u.next;
FREE_ZVAL_EX(&p->z);
p = q;
}
GC_G(collected) += count;
GC_G(free_list) = orig_free_list;
GC_G(next_to_free) = orig_next_to_free;
}
return count;
}

這裏只簡單的介紹其中關鍵的流程:

1.gc_mark_roots（）

這個函數對節點信息的鏈表進行一次深度優先遍歷，將其中的zval的refcount減1，爲了不對同一個zval重複減操做，在操做以後將zval標記成灰色。（對節點自身的zval能夠重複減操做，這個是此算法的基礎）

2.gc_scan_roots()

這個函數對節點信息的鏈表再次進行深度優先遍歷，若是發現zval的refcount大於等於1，則對該zval和其包含的zval的refcount加1操做，這個是對非垃圾的一個信息還原，而後將這些zval顏色屬性去掉(設置成black)。若是發現zval的refcount等於0，則就標記成白色，這些是後面將要清理掉的垃圾。

3.gc_collect_roots()

遍歷節點信息鏈表,將前面一個步驟中標記爲白色的節點信息放到GC_G(zval_to_free)爲入口的鏈表中，這個鏈表用來存放將要釋放的垃圾。而後釋放掉所有的節點信息，緩衝區被清空。分析結束後將從新收集節點信息。

4.釋放步驟3中收集到垃圾數據。