PHP - 垃圾回收机制

最新推荐文章于 2023-03-13 14:14:13 发布
最新推荐文章于 2023-03-13 14:14:13 发布
阅读量714 收藏
点赞数
分类专栏： php 文章标签： php
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mijar2016/article/details/53958356
版权

关于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);
    }
}
  1. 首先，执行Z_DELREF_P(zv),将zv的引用计数进行减1。
  2. 如果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。

a).gc_mark_roots:
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).gc_scan_roots:
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,则标记为白色状态。

c).gc_collect_roots:
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缓冲池回收操作。

mijar2016
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一看就懂系列之 由浅入深聊一聊php的垃圾回收机制
咖啡色的羊驼
08-08 1万+
转载请附上本文地址：前言是的，平时经常听到大牛说到的gc，就是垃圾回收器，全称Garbage Collection。早期版本，准确地说是5.3之前(不包括5.3)的垃圾回收机制，是没有专门的垃圾回收器的。只是简单的判断了一下变量的zval的refcount是否为0，是的话就释放否则不释放直至进程结束。乍一看确实没毛病啊，然而其中隐藏着变量内存溢出的风险：http://bugs.php.net/bug
PHP垃圾回收机制简单说明
12-18
PHP使用了引用计数(reference counting)这种单纯的垃圾回收(garbage collection)机制。每个对象都内含一个引用计数器，每个reference连接到对象，计数器加1。当reference离开生存空间或被设为NULL，计数器减1。当...
PHP中的垃圾回收相关函数
硬核项目经理
08-24 629
PHP中的垃圾回收相关函数之前我们已经学习过 PHP 中的引用计数以及垃圾回收机制的概念。这些内容非常偏理论，也是非常常见的面试内容。而今天介绍的则是具体的关于垃圾回收的一些功能函数。关...
利用PHP垃圾回收机制构造POP链
Tajang的大千世界
02-07 3196
一个小trick
垃圾回收机制--性能方面考虑的因素
zhaoliang831214的专栏
06-24 465
在上一节我们已经简单的提到：回收可能根有细微的性能上影响，但这是把PHP 5.2与PHP 5.3比较时才有的。尽管在PHP 5.2中，记录可能根相对于完全不记录可能根要慢些，而PHP 5.3中对 PHP run-time 的其他修改减少了这个性能损失。 这里主要有两个领域对性能有影响。第一个是内存占用空间的节省，另一个是垃圾回收机制执行内存清理时的执行时间增加(run-time delay)
PHP 垃圾回收机制(GC)
Aiwin的博客
10-30 3347
PHP 垃圾回收机制(GC)和例题。
浅析PHP7 的垃圾回收机制
10-16
垃圾回收机制是一种动态存储分配方案。它会自动释放程序不再需要的已分配的内存块。 这篇文章主要介绍了PHP7 的垃圾回收机制,需要的朋友可以参考下
PHP session垃圾回收机制实例分析
01-02
本文实例讲述了PHP session垃圾回收机制。分享给大家供大家参考，具体如下： session过期时间 在php.ini文件中有这样一个配置，这个配置表示session文件过期时间，默认的话是1440秒，也就是24分钟，这个24分钟是...
简单谈谈PHP的垃圾回收机制
12-17
2、定义一个变量的时候并不是每次都会扩大预定于值，因为PHP会在内存中先预占用一个空间，等你声明变量的时候就会分配给你，但是当你超出这个预占用空间之后，那么它就会增加空间，但是等你删除变量时候这个空间容量...
php gc是什么意思,GC及PHP GC学习笔记
weixin_39915500的博客
03-09 112
一、认识GCGarbage Collection，垃圾回收，缩写GC, 是计算机科学中一种自动内存管理机制，通常也说是垃圾回收机制和垃圾回收器。是美国科学家John McCarthy与1959年发明用于Lisp内存管理。简单说GC的作用就是把内存中程序不在使用的对象(称为垃圾)释放，归还给内存。这个过程实际上分为两步，第一步：识别收集垃圾标示出内存中哪些对象是垃圾。常用算法0、引用计数算法(Ref...
浅谈PHP中的GC回收机制
weixin_44770698的博客
03-13 783
浅谈PHP的GC回收机制
php 的垃圾回收机制
国内某知名游戏公司小菜鸡工程师
06-16 1882
学好垃圾回收机制，防止内存泄漏
PHP的垃圾回收机制详解
weixin_30284355的博客
01-06 292
最近由于使用php编写了一个脚本，模拟实现了一个守护进程，因此需要深入理解php中的垃圾回收机制。本文参考了PHP手册。 在理解PHP垃圾回收机制（GC）之前，先了解一下变量的存储。 php中变量存在于一个zval的变量容器中。结构如下： 类型 值 is_ref refcount ...
php垃圾回收机制
hu215545的博客
01-23 1433
一、概念 垃圾回收机制是一种动态存储分配的方案。它会自动释放程序不再需要的已分配的内存块。垃圾回收机制可以让程序员不必过分关心程序内存分配，从而将更多的精力投入到业务逻辑。在现在的流行各种语言当中，垃圾回收机制是新一代语言所共有的特征，如Python、PHP、C#、Ruby等都使用了垃圾回收机制。 二、PHP垃圾回收机制 1、在PHP5.3版本之前,使用的垃圾回收机制是单纯的“引用计数”。即： ①每个内存对象都分配一个计数器，当内存对象被变量引用时，计数器+1； ②当变量引用撤掉后（执行unset（）后），
从源码分析PHP的SESSION实现机制
risingsun001的专栏
03-23 4805
从源码分析PHP的SESSION实现，深入理解PHP的session机制。Session是以扩展的形式嵌入到PHP内核的，所以我们可以把Session当成扩展来看待。从整个PHP的生命周期来了解php的SESSION机制
php垃圾清理机制,PHP的GC垃圾收集机制
weixin_29046611的博客
03-09 223
每一种语言都有自己的自动垃圾回收机制，让程序员不必过分关心程序内存分配，但是在OOP中，有些对象需要显式的销毁；防止程序执行内存溢出。PHP 垃圾回收机制(Garbage Collector 简称GC)在PHP中，没有任何变量指向这个对象时，这个对象就成为垃圾。PHP会将其在内存中销毁；这是PHP 的GC垃圾处理机制，防止内存溢出。当一个 PHP线程结束时，当前占用的所有内存空间都会被销毁，当前程...
php中垃圾收集机制原理,PHP 垃圾回收机制详解
weixin_39615741的博客
03-10 276
原标题：PHP 垃圾回收机制详解PHP的基本GC概念PHP语言同其他语言一样，具有垃圾回收机制。那么今天我们要为大家讲解的内容就是关于PHP垃圾回收机制的相关问题。希望对大家有所帮助。PHP strtotime应用经验之谈PHP memory_get_usage管理内存PHP unset全局变量运用问题详解PHP unset函数销毁变量教你快速实现PHP全站权限验证一、PHP 垃圾回收机制(Gar...
PHP的垃圾回收机制是怎样的（腾讯）
www.phptuku.com——PHP全栈工程师的摇篮！
05-27 4701
PHP可以自动进行内存管理，清楚不再需要的对象。PHP使用了引用计数这种单纯的垃圾回收机制。每个对象都内含一个引用计数器，每个reference链接到对象，计数器加1，当reference离开生存空间或者被设为null,计数器减1，当某个引用计数器的对象为0时，PHP知道你将不再需要使用这个对象，释放其所占有的内存空间。
php与java的桥接--javabridge
最新发布
05-19
- 利用 Java 的高效内存管理和垃圾回收机制处理大量数据； - 利用 Java 的多线程和并发处理机制实现高并发应用程序； - 利用 Java 的企业级安全机制保护应用程序的安全性。 JavaBridge 在 PHP 和 Java 之间建立了一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值