Introduction to the garbage collection mechanism of the underlying principles of PHP (code example)

What this article brings to you is an introduction to the garbage collection mechanism (code examples) of the underlying principles of PHP. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

php garbage collection mechanism is a familiar but not very familiar content for PHPer. So how does PHP recycle unnecessary memory?

The internal storage structure of php variables

First of all, you need to understand the basic knowledge to facilitate the understanding of the principles of garbage collection. Everyone knows that php is written in C, so the internal storage structure of php variables will also be related to the C language, that is, the structure of zval:

struct _zval_struct {
    union {
        long lval;
        double dval;
        struct {
            char *val;
            int len;
        } str;
        HashTable *ht;
        zend_object_value obj;
        zend_ast *ast;
    } value;                    //变量value值
    zend_uint refcount__gc;   //引用计数内存中使用次数，为0删除该变量
    zend_uchar type;           //变量类型
    zend_uchar is_ref__gc;    //区分是否是引用变量
};

It can be seen from the content of the above structure that each php Variables will be composed of four parts: variable type, value value, reference count number and whether it is a reference variable

Note: The above zval structure is the structure after php5.3 version. Before php5.3, no new ones were introduced. The garbage collection mechanism, that is, GC, so there is no _gc in the name; and after the php7 version, the zval structure was rewritten due to performance issues, and the

reference counting principle

understands the php variables. After the internal storage structure, we will learn about the principles related to PHP variable assignment and the early garbage collection mechanism

Variable container

Non-array and object variables

Replace constants each time When assigning a value to a variable, a variable container will be generated

Example:

$a = '许铮的技术成长之路';
xdebug_debug_zval('a')

Result:

a: (refcount=1, is_ref=0)='许铮的技术成长之路'

array and object variables

will generate the number of elements Variable container of 1

Example:

$b = [
'name' => '许铮的技术成长之路',
'number' => 3
];
xdebug_debug_zval('b')

Result:

b: (refcount=1, is_ref=0)=array ('name' => (refcount=1, is_ref=0)='许铮的技术成长之路', 'number' => (refcount=1, is_ref=0)=3)

Principle of assignment (copy-on-write technology)

After understanding constant assignment, next We think about assignments between variables from a memory perspective

Example:

$a = [
'name' => '许铮的技术成长之路',
'number' => 3
]; //创建一个变量容器，变量a指向给变量容器，a的ref_count为1
$b = $a; //变量b也指向变量a指向的变量容器，a和b的ref_count为2
xdebug_debug_zval('a', 'b');
$b['name'] = '许铮的技术成长之路1';//变量b的其中一个元素发生改变，此时会复制出一个新的变量容器，变量b重新指向新的变量容器，a和b的ref_count变成1
xdebug_debug_zval('a', 'b');

Result:

a: (refcount=2, is_ref=0)=array ('name' => (refcount=1, is_ref=0)='许铮的技术成长之路', 'number' => (refcount=1, is_ref=0)=3)
b: (refcount=2, is_ref=0)=array ('name' => (refcount=1, is_ref=0)='许铮的技术成长之路', 'number' => (refcount=1, is_ref=0)=3)
a: (refcount=1, is_ref=0)=array ('name' => (refcount=1, is_ref=0)='许铮的技术成长之路', 'number' => (refcount=1, is_ref=0)=3)
b: (refcount=1, is_ref=0)=array ('name' => (refcount=1, is_ref=0)='许铮的技术成长之路1', 'number' => (refcount=1, is_ref=0)=3)

So, when variable a is assigned to variable b, it is not generated immediately A new variable container, instead, variable b points to the variable container pointed by variable a, that is, memory "sharing"; and when one element of variable b changes, the variable container copy will actually occur. This is Copy-on-write technology

Reference count cleared to 0

When the ref_count of the variable container is cleared to 0, it means that the variable container will be destroyed, realizing memory recycling, which is alsoGarbage collection mechanism before version php5.3

Example:

$a = "许铮的技术成长之路";
$b = $a;
xdebug_debug_zval('a');
unset($b);
xdebug_debug_zval('a');

Result:

a: (refcount=2, is_ref=0)='许铮的技术成长之路'
a: (refcount=1, is_ref=0)='许铮的技术成长之路'

Memory leak problem caused by circular reference

However, there is a loophole in the garbage collection mechanism before php5.3, that is, when a child element within an array or object refers to its parent element, and if its parent element is deleted at this time, the variable container will not be deleted. Because its child elements are still pointing to the variable container, but since there are no symbols pointing to the variable container in any scope, they cannot be cleared, so a memory leak will occur until the script execution ends

Example:

$a = array( 'one' );
$a[] = &$a;
xdebug_debug_zval( 'a' );

Since this example is not easy to output, it is represented by a diagram, as shown in the figure:

##Example:

unset($a);
xdebug_debug_zval('a');

As shown in the figure ：

New garbage collection mechanism

The root buffering mechanism is introduced after version php5.3, that is, the default setting of the specified zval number when PHP starts Root buffer (default is 10000), when PHP finds that there is a zval with circular reference, it will be put into the root buffer. When the root buffer reaches the specified number in the configuration file (default is 10000), it will Carry out garbage collection to solve the memory leak problem caused by circular references

Guidelines for confirming garbage

1. If the reference count is reduced to zero, the variable container will be cleared (free), Not garbage

2. If the reference count of a zval is still greater than 0 after being reduced, then it will enter the garbage cycle. Secondly, during a garbage cycle, find out which parts are garbage by checking whether the reference count is reduced by 1 and checking which variable containers have zero references.

Summary

Garbage collection mechanism:

1. Based on PHP’s reference counting mechanism (only this mechanism was available before PHP5.3)
2. Use the root buffer mechanism at the same time , when PHP finds that there is a zval with circular reference, it will put it into the root buffer. When the root buffer reaches the specified number in the configuration file, garbage collection will be performed to solve the memory leak caused by circular reference. Problem (php5.3 started to introduce this mechanism)

The above is the detailed content of Introduction to the garbage collection mechanism of the underlying principles of PHP (code example). For more information, please follow other related articles on the PHP Chinese website!