【PHP7源码学习】2019-04-01 PHP垃圾回收1

时间  2019-11-10
标签 PHP7源码学习 php 垃圾 回收 栏目 PHP 繁體版
原文   原文链接

baiyanphp

所有视频：https://segmentfault.com/a/11...算法

垃圾回收触发条件

  • 咱们知道，在PHP中，若是一个变量的引用计数减小到0（没有任何地方在使用这个变量），它所占用的内存就会被PHP虚拟机自动回收，并不会被当作垃圾。垃圾回收的触发条件是当一个变量的引用计数的值减小1以后，仍不为0（还有某个地方在使用这个变量），才有可能是垃圾。须要让咱们人工去对其进行进一步的检验，看它是否真的是垃圾，而后再作后续的操做。一个典型的例子就是在咱们使用数组与对象的过程当中可能存在的循环引用问题。它会让某个变量本身引用本身。看下面一个例子:
<?php
$a = ['time' => time()];
$a[] = &$a; //循环引用
unset($a);
  • 咱们能够知道，unset($a)以后，$a的type类型变成了0(IS_UNDEF)，同时其指向的zend_reference结构体的refcount变为了1（由于$a数组中的元素仍然在引用它），咱们画图来表示一下如今的内存状况：

  • 那么问题出现了，$a是unset掉了，可是因为原始的zend_array中的元素仍然在指向仍然在指向zend_reference结构体，因此zend_reference的refcount是1，而并不是是预期的0。这样一来，这两个zend_reference与zend_array结构在unset($a)以后，仍然存在于内存之中，若是对此不做任何处理，就会形成内存泄漏。
  • 以上详细的讲解请看：【PHP源码学习】2019-03-19 PHP引用
  • 那么如何解决循环引用带来的内存泄漏问题呢？咱们的垃圾回收就要派上用场了。
  • 在PHP7中，垃圾回收分为垃圾回收器和垃圾回收算法两大部分
  • 在这篇笔记中只讲解第一部分：垃圾回收器

垃圾回收器

  • 在PHP7中，若是检测到refcount减1后仍大于0的变量，会首先把它放入一个双向链表中，它就是咱们的垃圾回收器。这个垃圾回收器至关于一个缓冲区的做用，待缓冲区满了以后，等待垃圾回收算法进行后续的标记与清除操做。
  • 垃圾回收算法的启动时机并非简单的有一个疑似垃圾到来，就要运行一次，而是待缓冲区存满了以后（规定10001个存储单元），而后垃圾回收算法才会启动，对缓冲区中的疑似垃圾进行最终的标记和清除。这个垃圾回收器缓冲区的做用就是减小垃圾回收算法运行的频率，减小对操做系统资源的占用以及对正在运行的服务端代码的影响，下面咱们经过代码来详细讲解。

垃圾回收器存储结构

  • 垃圾回收器的结构以下：
typedef struct _gc_root_buffer {
    zend_refcounted          *ref;          
    struct _gc_root_buffer   *next;     //双向链表，指向下一个缓冲区单元
    struct _gc_root_buffer   *prev;     //双向链表，指向上一个缓冲区单元
    uint32_t                 refcount;
} gc_root_buffer;
  • 垃圾回收器是一个双向链表，那么如何维护这个双向链表首尾指针的信息，还有缓冲区的使用状况等额外信息呢，如今就须要使用咱们的全局变量zend_gc_globals了：
typedef struct _zend_gc_globals {
    zend_bool         gc_enabled;         //是否启用gc
    zend_bool         gc_active;          //当前是否正在运行gc
    zend_bool         gc_full;              //缓冲区是否满了

    gc_root_buffer   *buf;                  /*指向缓冲区头部 */
    gc_root_buffer    roots;              /*当前处理的垃圾缓冲区单元，注意这里不是指针*/
    gc_root_buffer   *unused;              /*指向未使用的缓冲区单元链表开头（用于串联缓冲区碎片）*/
    gc_root_buffer   *first_unused;          /*指向第一个未使用的缓冲区单元*/
    gc_root_buffer   *last_unused;          /*指向最后一个未使用的缓冲区单元 */

    gc_root_buffer    to_free;            
    gc_root_buffer   *next_to_free;
    ...
    
} zend_gc_globals;

垃圾回收器初始化

  • 那么如今，咱们须要为垃圾回收器分配内存空间，以存储接下来可能到来的可疑垃圾，咱们经过gc_init()函数实现空间的分配：
ZEND_API void gc_init(void)
{
    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();
    }
}
  • GC_G这个宏是取得以上zend_gc_globals结构体中的变量。咱们如今尚未生成缓冲区，因此进入这个if分支。经过系统调用malloc分配一块内存，这个内存的大小是单个缓冲区结构体的大小 * 10001：
#define GC_ROOT_BUFFER_MAX_ENTRIES 10001
  • 那么如今咱们获得了大小为10001的缓冲区（第1个单元不用），并把指针的步长置为gc_root_buffer类型，随后将它的last_unused指针指向缓冲区的末尾，而后经过gc_reset()作一些初始化操做：
ZEND_API void gc_reset(void)
{
    GC_G(gc_runs) = 0;
    GC_G(collected) = 0;
    GC_G(gc_full) = 0;
    ...

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

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

    if (GC_G(buf)) {                         //因为咱们以前分配了缓冲区，进这里
        GC_G(unused) = NULL;                 //没有缓冲区碎片，置指针为NULL
        GC_G(first_unused) = GC_G(buf) + 1;  //将指向第一个未使用空间的指针日后挪1个单元的长度
    } else {
        GC_G(unused) = NULL;
        GC_G(first_unused) = NULL;
        GC_G(last_unused) = NULL;
    }

    GC_G(additional_buffer) = NULL;
}
  • 根据这个函数中的内容，咱们能够画出当前的内存结构图：

将疑似垃圾存入垃圾回收器

  • 这样一来，咱们垃圾回收器缓冲区就初始化完毕了，如今等着zend虚拟机收集可能会是垃圾的变量，存入这些缓冲区中，这步操做经过gc_possible_root(zend_refcounted *ref)函数完成：
ZEND_API void ZEND_FASTCALL gc_possible_root(zend_refcounted *ref)
{
    gc_root_buffer *newRoot;

    if (UNEXPECTED(CG(unclean_shutdown)) || UNEXPECTED(GC_G(gc_active))) {
        return;
    }

    ZEND_ASSERT(GC_TYPE(ref) == IS_ARRAY || GC_TYPE(ref) == IS_OBJECT);
    ZEND_ASSERT(EXPECTED(GC_REF_GET_COLOR(ref) == GC_BLACK));
    ZEND_ASSERT(!GC_ADDRESS(GC_INFO(ref)));

    GC_BENCH_INC(zval_possible_root);

    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)) {
            return;
        }
        GC_REFCOUNT(ref)++;
        gc_collect_cycles();
        GC_REFCOUNT(ref)--;
        if (UNEXPECTED(GC_REFCOUNT(ref)) == 0) {
            zval_dtor_func(ref);
            return;
        }
        if (UNEXPECTED(GC_INFO(ref))) {
            return;
        }
        newRoot = GC_G(unused);
        if (!newRoot) {
#if ZEND_GC_DEBUG
            if (!GC_G(gc_full)) {
                fprintf(stderr, "GC: no space to record new root candidate\n");
                GC_G(gc_full) = 1;
            }
#endif
            return;
        }
        GC_G(unused) = newRoot->prev;
    }

    GC_TRACE_SET_COLOR(ref, GC_PURPLE);
    GC_INFO(ref) = (newRoot - GC_G(buf)) | GC_PURPLE;
    newRoot->ref = ref;

    newRoot->next = GC_G(roots).next;
    newRoot->prev = &GC_G(roots);
    GC_G(roots).next->prev = newRoot;
    GC_G(roots).next = newRoot;

    GC_BENCH_INC(zval_buffered);
    GC_BENCH_INC(root_buf_length);
    GC_BENCH_PEAK(root_buf_peak, root_buf_length);
}
  • 代码有点长没关系，咱们逐行分析。首先又声明了一个指向缓冲区的指针newRoot。接下来判断若是垃圾回收器已经运行，那么本次就再也不执行了。而后将zend_gc_globals全局变量上的unused指针字段赋值给newRoot指针，然而unused指针为NULL（由于没有缓冲区碎片），因此newRoot此时也为NULL。故接下来进入else if分支：
newRoot = GC_G(first_unused);
    GC_G(first_unused)++;
  • 首先将newRoot指向第一个未使用的缓冲区单元，因此下一行须要将第一个未使用的缓冲区单元日后挪一个单元，方便下一次的使用，很好理解，跳过这个长长的else分支往下继续执行：
GC_TRACE_SET_COLOR(ref, GC_PURPLE);
    GC_INFO(ref) = (newRoot - GC_G(buf)) | GC_PURPLE;
    newRoot->ref = ref;

    newRoot->next = GC_G(roots).next;
    newRoot->prev = &GC_G(roots);
    GC_G(roots).next->prev = newRoot;
    GC_G(roots).next = newRoot;
  • 第一行GC_TRACE这个宏用来打印相关DEBUG信息，咱们略过这一行。
  • 第二行执行GC_INFO(ref) = (newRoot - GC_G(buf)) | GC_PURPLE;咱们看到这里有一个GC_PURPLE，也就是颜色的概念。在PHP垃圾回收中，用到了4种颜色：
#define GC_BLACK  0x0000
#define GC_WHITE  0x8000
#define GC_GREY   0x4000
#define GC_PURPLE 0xc000
  • 源码中对它们的解释以下：
* BLACK  (GC_BLACK)   - In use or free.
 * GREY   (GC_GREY)    - Possible member of cycle.
 * WHITE  (GC_WHITE)   - Member of garbage cycle.
 * PURPLE (GC_PURPLE)  - Possible root of cycle.
  • 这里咱们先不对每一种颜色作详细解释。咱们用(newRoot - GC_G(buf)) | GC_PURPLE的意思是：newRoot - GC_G(buf)(缓冲区起始地址)表明当前使用的缓冲区的偏移量，再与0xc000作或运算，结果拼装到变量的gc_info字段中，这个字段是一个uint16类型，因此能够利用前2位把它标记成紫色，同时利用后14位存储偏移量。最终字段按位拆开的状况如图：

  • 第三行：将当前引用赋值到当前缓冲区中
  • 接下来是双向链表的指针操做：
newRoot->next = GC_G(roots).next;
    newRoot->prev = &GC_G(roots);
    GC_G(roots).next->prev = newRoot;
    GC_G(roots).next = newRoot;
  • 其目的是将当前缓冲区的prev和next指针指向全局变量中的root字段，同时将全局变量中的root字段的prev与next指针指向当前使用的缓冲区。

  • 至此，咱们就能够将全部疑似垃圾的变量都放到缓冲区中，一直存下去，待存满缓冲区10000个存储单元以后，垃圾回收算法就会启动，对缓冲区中的全部疑似垃圾进行标记与清除，垃圾回收算法的过程会在下一篇笔记进行讲解。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程