Home > Article > Backend Development > Chat about php7 garbage collection mechanism
PHP7The column introduces the garbage collection mechanism
Recommended (free): PHP7
Article directory
When understanding our php GC, I think it is necessary for me to introduce the underlying implementation of our php variables.
The structure of zval
// php 变量对于的c结构体
struct _zval_struct {
zend_value value;
union {
……
} u1;
union {
……
} u2;
};
Since it mainly talks about garbage collection, here is a brief introduction to the functions of the u1 u2 unionu1 The structure is relatively complex. I think it is mainly used to identify variable typesu2 Most of them are auxiliary fields, the implementation of internal functions of variables, improving cache friendliness, etc.
Next is us The protagonist
zend_value It is also a union embedded in the structure
typedef union _zend_value {
zend_long lval;//整形
double dval;//浮点型
zend_refcounted *counted;//获取不同类型的gc头部
zend_string *str;//string字符串
zend_array *arr;//数组
zend_object *obj;//对象
zend_resource *res;//资源
zend_reference *ref;//是否是引用类型
// 忽略下面的结构，与我们讨论无关
zend_ast_ref *ast;
zval *zv;
void *ptr;
zend_class_entry *ce;
zend_function *func;
struct {
ZEND_ENDIAN_LOHI(
uint32_t w1,
uint32_t w2)
} ww;
} zend_value;
The reference count is recorded in the value of zvalzend_refcounted *countedThis type, our garbage collection mechanism is also based on this.
typedef struct _zend_refcounted_h {
uint32_t refcount; /* reference counter 32-bit */
union {
struct {
ZEND_ENDIAN_LOHI_3(
zend_uchar type,
zend_uchar flags, /* used for strings & objects */
uint16_t gc_info) /* keeps GC root number (or 0) and color */
} v;
uint32_t type_info;
} u;
} zend_refcounted_h;
The definition of all complex types starts with the zend_refcounted_h structure. In addition to reference counting, this structure also has GC-related structures. Therefore, when doing GC recycling , GC does not need to care about the specific type, all of it can be processed as a zend_refcounted* structure.
#Automatic recycling of variables
In PHP except array and object type variables, most of the rest are automatically recycled
PHP The recycling of ordinary variables is related to the number of references to the variable.
Official example
$a = 1;
$b = $a;
xdebug_debug_zval('a');
$a =10;
xdebug_debug_zval('a');
unset($a);
xdebug_debug_zval('a');
Result
a: (refcount=2, is_ref=0),int 1 a: (refcount=1, is_ref=0),int 10 a: no such symbol
You can see that when $a =10 it involves php’s COW (copy-on- write) mechanism, $b will copy the original $a, canceling the reference relationship between them, so the number of references (refcount) of a is reduced to 1.
Then the number of references to a becomes 0 after we uset($a). This will be considered a garbage variable and free up space.
Give an example
$a = [1]; $a[1] = &$a; unset($a);
The type of $a before unset($a) is a reference type
a: (refcount=2, is_ref=1), array (size=2) 0 => (refcount=1, is_ref=0),int 1 1 => (refcount=2, is_ref=1), &array<p><img src="https://img.php.cn/upload/article/000/000/052/163e22c0271ab639b6a5080b1ccd0d58-0.jpg" alt=""></p><p>unset($ a) After that, it becomes like this</p><p><img src="https://img.php.cn/upload/article/000/000/052/163e22c0271ab639b6a5080b1ccd0d58-1.jpg" alt=""></p><p>At this time, when we <code>unset</code> operate, the refcount changes from 2 to 1 because there is an internal reference pointing to $a , so the space it occupies externally will not be destroyed. </p><p>Then our external reference has been interrupted and we cannot use it. It becomes an "orphan", which is called a wild pointer in the C language. In php it's called a circular reference. Memory leak. If you want to destroy the variable, you can only wait for the php script to end. </p><p><strong>Memory leaks caused by circular references</strong></p><p>In order to clean up this garbage, two criteria are introduced</p>
Circular references basically only appear in arrays and objects. The object is because it itself is a reference
The recycling process of object and array
Garbage collection in php7 consists of two parts, one is the garbage collector and the other is the garbage collection algorithm.
The garbage collector collects the elements just mentioned that may be garbage into the recycling pool, that is, the variable zend_refcount>0 is placed in the recycling pool. When the value of the recycling pool reaches a certain amount, it will be traversed uniformly. Perform simulated deletion. If zend_refcount=0, it is considered garbage and deleted directly.
Traverse every variable in the recycling pool, and then traverse each member based on each variable. If the members are still nested, continue traversing. Then set the simulated refcount of all members to -1. If the reference count of the external variable is 0 at this time. Then it can be considered garbage, clearly. If it is greater than 0, then the number of references is restored and taken out from the garbage collection pool.
The principle of garbage collection
If your variable is not garbage, then after the references of all its member variables are reduced by one, the reference of the total variable will definitely not be 0.
Example
It’s rather hard to say, so why not give an example. When I first browsed sf.gg, I saw a question about GC, and I answered it. About the GC garbage collection mechanism
The topic is as follows
//我的回答 1、只要zval.value的refcount减一，然后缺其refcount的值不为0那么它就可能是垃圾，进入垃圾周期。 2、进入垃圾池遍历所有成员，包括其嵌套的成员，都对其做 refcount-1的操作，看外部的引用是否为0。 那么对于 题主的问题来说， 首先，你要想$a为垃圾，一定要先对 unset($a)操作，那么此时 $a的 refcount = 2 对于$a[0] refcount-1 不影响外部的$a， $a[1] refcount-1 ，此时 $a的 refount=1 $a[2] refcount-1 ,此时 $a 的 refount=0 模拟减结束，那么此变量被当成垃圾回收。
更多编程相关知识，请访问：编程教学！！
The above is the detailed content of Chat about php7 garbage collection mechanism. For more information, please follow other related articles on the PHP Chinese website!