您的位置：首页 > 编程语言 > PHP开发

PHP - 垃圾回收机制

2016-12-31 21:33 423 查看

关于PHP垃圾回收机制(简称GC)，网上已经有很多相关资料。之所以决定写这篇文章，主要是为了加深自己对PHP垃圾回收机制的理解。当然，如果能帮助到其他人理解，也不失为一件快事。

PHP5.3及以上版本使用了新垃圾回收机制。我们可以通过修改php.ini配置开启或关闭GC机制(默认是打开状态)。

zend.enable_gc = On

GC数据结构

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;
typedef struct _zval_gc_info {
zval z;
union {
gc_root_buffer       *buffered;
struct _zval_gc_info *next;
} u;
} zval_gc_info;
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; //gc_collect_cycles执行次数
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;

PHP内部定义了一个

zend_gc_globals

全局对象来管理GC。

zend_gc_globals

->buf：GC缓冲池，其为一个双向链表结构。

zend_gc_globals

->roots: GC缓冲池的根节点。

这里有一个比较特殊的结构：

zval_gc_info

，它被作为变量的新数据结构。在zend_gc.h文件，覆盖zend_alloc.h定义的

ALLOC_ZVAL

和

FREE_ZVAL

函数。

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

从上面的代码，我们可以看出新的变量结构比原结构多出了一个GC相关的指针信息。

GC初始化

SAPI启动时，系统会执行

php_module_startup

函数。在

php_module_startup

函数内部会调用

zend_register_standard_ini_entries

函数，该函数用于初始化zend配置功能。

ZEND_INI_BEGIN()
ZEND_INI_ENTRY("error_reporting",               NULL,       ZEND_INI_ALL,       OnUpdateErrorReporting)
STD_ZEND_INI_BOOLEAN("zend.enable_gc",              "1",    ZEND_INI_ALL,       OnUpdateGCEnabled,      gc_enabled,     zend_gc_globals,        gc_globals)
#ifdef ZEND_MULTIBYTE
STD_ZEND_INI_BOOLEAN("detect_unicode", "1", ZEND_INI_ALL, OnUpdateBool, detect_unicode, zend_compiler_globals, compiler_globals)
#endif
ZEND_INI_END()

以上是zend定义的配置结构体，对于GC，最终会执行

OnUpdateGCEnabled

函数。

static ZEND_INI_MH(OnUpdateGCEnabled)
{
OnUpdateBool(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
if (GC_G(gc_enabled)) {
gc_init(TSRMLS_C);
}
return SUCCESS;
}

GC_G(gc_enabled)

为True时，表示开启GC，然后系统会执行

gc_init

进行初始化操作。

#define GC_ROOT_BUFFER_MAX_ENTRIES 10000
#define GC_G(v) (gc_globals.v)
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);
}
}

系统先为GC分配了GC_ROOT_BUFFER_MAX_ENTRIES*sizeof(gc_root_buffer)的内存。GC_ROOT_BUFFER_MAX_ENTRIES为硬编码，并定义为10000。然后，将GC_G(last_unused)指向&GC_G(buf)[GC_ROOT_BUFFER_MAX_ENTRIES]位置。最后，再调用

gc_reset()

重置gc_globals各属性值。

ZEND_API void gc_reset(TSRMLS_D)
{
GC_G(gc_runs) = 0;
GC_G(collected) = 0;

#if GC_BENCH
GC_G(root_buf_length) = 0;
GC_G(root_buf_peak) = 0;
GC_G(zval_possible_root) = 0;
GC_G(zobj_possible_root) = 0;
GC_G(zval_buffered) = 0;
GC_G(zobj_buffered) = 0;
GC_G(zval_remove_from_buffer) = 0;
GC_G(zobj_remove_from_buffer) = 0;
GC_G(zval_marked_grey) = 0;
GC_G(zobj_marked_grey) = 0;
#endif

GC_G(roots).next = &GC_G(roots);
GC_G(roots).prev = &GC_G(roots);

if (GC_G(buf)) {
GC_G(unused) = NULL;
GC_G(first_unused) = GC_G(buf);

GC_G(zval_to_free) = NULL;
} else {
GC_G(unused) = NULL;
GC_G(first_unused) = NULL;
GC_G(last_unused) = NULL;
}
}

GC回收

当我们调用unset()回收变量时，PHP会执行

_zval_ptr_dtor

函数。

ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
{
zval *zv = *zval_ptr;
#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
//zv refcount__gc-- 引用计数-1
Z_DELREF_P(zv);
if (Z_REFCOUNT_P(zv) == 0) {
TSRMLS_FETCH();
//如果引用计数为0，则直接回收变量
if (zv != &EG(uninitialized_zval)) {
GC_REMOVE_ZVAL_FROM_BUFFER(zv);
zval_dtor(zv);
efree_rel(zv);
}
} else {
TSRMLS_FETCH();
//如果引用计数=1，则重置is_ref__gc属性
if (Z_REFCOUNT_P(zv) == 1) {
Z_UNSET_ISREF_P(zv);
}

GC_ZVAL_CHECK_POSSIBLE_ROOT(zv);
}
}

首先，执行

Z_DELREF_P(zv)

,将zv的引用计数进行减1。

如果

Z_REFCOUNT_P(zv) == 0

条件成立，表明zv的引用计数为0，则直接释放变量；否则，执行

else

部分代码，根据

Z_REFCOUNT_P(zv)

值判断是否需要重置

is_ref_gc

属性(即引用调用)，然后执行

GC_ZVAL_CHECK_POSSIBLE_ROOT(zv)

。

#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)
{
//判断z类型是否是数组或者对象
if (z->type == IS_ARRAY || z->type == IS_OBJECT) {
gc_zval_possible_root(z TSRMLS_CC);
}
}

从上面的代码可以看出，

GC_ZVAL_CHECK_POSSIBLE_ROOT

被定义为

gc_zval_check_possible_root

函数。当

zv

为数组和对象类型时，系统会执行

gc_zval_possible_root

函数。

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);
//GC_PURPLE 紫色表示已放入缓冲区
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 {
//gc未开启
if (!GC_G(gc_enabled)) {
GC_ZVAL_SET_BLACK(zv);
return;
}
zv->refcount__gc++;
//缓冲区满了 则调用gc_collect_cycles进行回收
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;
}
//添加至roots
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_G(unused)

：未使用的buf。

GC_G(first_unused)：指向第一个未使用的buf。

GC_G(last_unused)

：指向最后一个未使用的buf。

GC_G(roots)
：链表的根节点。

上面的代码很容易理解。

1. 判断zv
是否为对象类型，若是，则调用GC_ZOBJ_CHECK_POSSIBLE_ROOT
，并return，否则，继续执行。

2. 判断GC_ZVAL_GET_COLOR(zv) != GC_PURPLE
(GC_PURPLE表示紫色状态)条件是否成立，即zv
是否已加入回收缓冲区，如果是，则退出，否则继续执行。

3. 将zv
标记为紫色。判断GC缓存区是否有空间，如果已满，则调用gc_collect_cycles
进行回收。最后将zv
添加到GC缓存列表。

GC_ZOBJ_CHECK_POSSIBLE_ROOT
的流程与上面类似，这里就不单独介绍。

再来看看gc_collect_cycles
代码：

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 */
//回调对象__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;
}


这里有3个非常重要的函数：gc_mark_roots
、gc_scan_roots
、gc_collect_roots
。

[b]a).gc_mark_roots
:[/b]

static void gc_mark_roots(TSRMLS_D)
{
gc_root_buffer *current = GC_G(roots).next;
while (current != &GC_G(roots)) {
if (current->handle) {
//对象
if (EG(objects_store).object_buckets) {
struct _store_object *obj = &EG(objects_store).object_buckets[current->handle].bucket.obj;
if (GC_GET_COLOR(obj->buffered) == GC_PURPLE) {
zval z;
INIT_PZVAL(&z);
Z_OBJ_HANDLE(z) = current->handle;
Z_OBJ_HT(z) = current->u.handlers;
zobj_mark_grey(obj, &z TSRMLS_CC);
} else {
GC_SET_ADDRESS(obj->buffered, NULL);
GC_REMOVE_FROM_BUFFER(current);
}
}
} else {
//数组
if (GC_ZVAL_GET_COLOR(current->u.pz) == GC_PURPLE) {
//标记u.pz状态
zval_mark_grey(current->u.pz TSRMLS_CC);
} else {
GC_ZVAL_SET_ADDRESS(current->u.pz, NULL);
GC_REMOVE_FROM_BUFFER(current);
}
}
current = current->next;
}
}


gc_mark_roots
的功能是从roots
根节点进行遍历，然后调用zval_mark_grey
函数将各元素标记为灰色状态。zval_mark_grey
采用深搜遍历，变量refcount__gc
属性进行减一,并标记为灰色。

[b]b).gc_scan_roots:[/b]

static void gc_scan_roots(TSRMLS_D)
{
gc_root_buffer *current = GC_G(roots).next;
while (current != &GC_G(roots)) {
if (current->handle) {
zval z;

INIT_PZVAL(&z);
Z_OBJ_HANDLE(z) = current->handle;
Z_OBJ_HT(z) = current->u.handlers;
zobj_scan(&z TSRMLS_CC);
} else {
zval_scan(current->u.pz TSRMLS_CC);
}
current = current->next;
}
}


从GC_G(roots)根节点进行遍历，逐个调用zval_scan
修改变量标识。zval_scan
采用深搜遍历，对于refcount_gc
>0的变量,重置为黑色正常状态，对于refcount_gc
=0,则标记为白色状态。

[b]c).gc_collect_roots:[/b]

static void gc_collect_roots(TSRMLS_D)
{
gc_root_buffer *current = GC_G(roots).next;

while (current != &GC_G(roots)) {
if (current->handle) {
if (EG(objects_store).object_buckets) {
struct _store_object *obj = &EG(objects_store).object_buckets[current->handle].bucket.obj;
zval z;

GC_SET_ADDRESS(obj->buffered, NULL);
INIT_PZVAL(&z);
Z_OBJ_HANDLE(z) = current->handle;
Z_OBJ_HT(z) = current->u.handlers;
zobj_collect_white(&z TSRMLS_CC);
}
} else {
//current->handle = 0
GC_ZVAL_SET_ADDRESS(current->u.pz, NULL);
zval_collect_white(current->u.pz TSRMLS_CC);
}

GC_REMOVE_FROM_BUFFER(current);
current = current->next;
}
}


gc_collect_roots
收集标记为白色的变量，添加至GC_G(zval_to_free)列表中，并对变量refcount_gcc
属性加1操作。

以上就是GC回收的整个过程介绍。引用PHP官方手册一句话进行概括：“模拟删除”->“模拟恢复”->“真正删除”。

GC回收的流程图:



总结
对于复杂多层嵌套引用的数组及对象变量，GC使用深搜遍历标记法进行回收变量。考虑到PHP性能问题，此处引入了一个缓冲区机制，减少遍历删除执行的次数。

我们可能想到遇到一个非常极端的情况：“当某个PHP脚本存在大量的嵌套引用数组或对象，且引用后变量都执行了unset操作，但由于GC缓冲区未满，使得占用的空间位进行释放，从而可能导致内存溢出的情况，影响到脚本后面的运行”。

那么针对这种情况，我们可以通过调用PHPgc_collect_cycles函数人为触发GC缓冲池回收操作。


                                        
                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理  
                    
                    
                    
                        
                         标签： 
                                                php



            
                相关文章推荐
                
                
                    
                                                                        PHP 垃圾回收机制
                                                PHP垃圾回收机制简单说明
                                                PHP垃圾回收机制
                                                PHP内核探索：PHP5.3的垃圾回收机制
                                                PHP5.2和PHP5.3的垃圾回收机制
                                                PHP新的垃圾回收机制:Zend GC详解
                                                php垃圾回收机制
                                                php垃圾回收机制
                                                PHP的析构函数和垃圾回收机制
                                                php垃圾回收机制分析
                                                PHP垃圾回收机制简单说明
                                                PHP垃圾回收机制简单说明
                                                PHP垃圾回收机制防止内存溢出
                                                PHP垃圾回收机制简单说明
                                                php垃圾回收机制
                                                PHP垃圾回收机制
                                                PHP垃圾回收机制防止内存溢出
                                                PHP垃圾回收机制
                                                PHP垃圾回收机制
                                                PHP 的垃圾回收机制一些认识


        
            
            
            
                
                    新的分享
                    
                        
                                                        我不是针对Java，但抓住高并发的核心后，PHP完胜了 - 运维
                                                        RTThread 重定义rt_hw_console_output函数
                                                        php开发中常用的几个技巧
                                                        HCNP Routing&Switching之RSTP保护
                                                        HCNP Routing&Switching之RSTP
                                                        SMTP协议解读以及如何使用SMTP协议发送电子邮件
                                                        关于Jitpack发布aar，会丢失内置依赖库问题
                                                        PHP 8新特性之JIT简介
                                                        第10讲：Flink Side OutPut 分流
                                                        Matplotlib直方图绘制中的参数bins和rwidth
                                                        PotPlayer 直链下载
                                                        CVE-2020-26935 phpMyAdmin后台SQL注入
                                                    
                    
                
            

            
                
                    章节导航