Home > Article > Backend Development > Detailed explanation of GC mechanism in PHP
Detailed explanation of GC mechanism in PHP
- *文Original
- 2017-12-27 14:12:384259browse
This article mainly introduces the interpretation of the garbage collection mechanism in PHP. Whether it has GC function is an important concern in the development of a programming language. I hope to be helpful.
Basic GC concept of PHP
The PHP language, like other languages, has a garbage collection mechanism. So what we want to explain to you today is related to the PHP garbage collection mechanism. I hope to be helpful. PHP strtotime application experience PHP memory_get_usage() manages memory PHP unset global variable usage problems detailed explanation PHP unset() function destroys variables to teach you to quickly implement PHP full site permission verification 1. PHP garbage collection mechanism (Garbage Collector, referred to as GC) in PHP , when no variables point to this object, this object becomes garbage. PHP will destroy it in memory; this is PHP's GC garbage disposal mechanism to prevent memory overflow. When a PHP thread ends, all memory space currently occupied will be destroyed, and all objects in the current program will be destroyed at the same time. The GC process generally starts running with each SESSION. The purpose of gc is to automatically destroy and delete the session files after they expire. 2. __destruct /unset __destruct() The destructor is executed when the garbage object is recycled.
unset destroys the variable pointing to the object, not the object. 3. Session and PHP garbage collection mechanism Due to the working mechanism of PHP, it does not have a daemon thread to regularly scan Session information and determine whether it is invalid. When a valid request occurs, PHP will use the global variables session.gc_probability and session The value of .gc_pisor determines whether to enable a GC. By default, session.gc_probability=1, session.gc_pisor =100 means there is a 1% possibility of starting a GC (that is, there is only one gc in 100 requests) Will be started with one of the 100 requests). The job of the PHP garbage collection mechanism is to scan all Session information, subtract the last modification time of the session from the current time, and compare it with the session.gc_maxlifetime parameter. If the survival time exceeds gc_maxlifetime (default 24 minutes), the session will be deleted.
However, if your web server has multiple sites, GC may have unexpected results when processing sessions at multiple sites. The reason is: when GC is working, it will not distinguish between sessions of different sites. So at this time How to solve it?
1. Modify session.save_path, or use session_save_path() to save the session of each site to a dedicated directory.
2. Provide the startup rate of GC. Naturally, the startup rate of PHP garbage collection mechanism is improved, and the system The performance will also be reduced accordingly and is not recommended.
3. Determine the survival time of the current session in the code and delete it using session_destroy().
Basic knowledge of reference counting
Each PHP variable exists in a variable container called "zval". A zval variable container, in addition to containing the type and value of the variable, It also includes two bytes of additional information. The first one is "is_ref", which is a bool value used to identify whether this variable belongs to a reference set. Through this byte, the PHP engine can combine ordinary variables and references. Variables are distinguished. Since PHP allows users to use custom references by using &, there is also an internal reference counting mechanism in the zval variable container to optimize memory usage. The second extra byte is "refcount", used to indicate the pointer to this The number of variables (also called symbols) in the zval variable container.
When a variable is assigned a constant value, a zval variable container will be generated, as shown in the following example:
<?php
$a = "new string";
?>
In the above example, the new variable is a, which is generated in the current scope. And the type is string and the value is Variable container for "new string". In the extra two bytes of information, "is_ref" is set to false by default because no custom reference is generated. "refcount" is set to 1 because there is only one variable here Use this variable container. Call xdebug to view the variable content:
<?php
$a = "new string";
xdebug_debug_zval('a');
?>
The above code will output:
a: (refcount=1, is_ref=0)='new string'
Add a reference count to variable a
<?php
$a = "new string";
$b = $a;
xdebug_debug_zval('a');
?>
The above code will output:
a: (refcount=2, is_ref=0)='new string'
##At this time, the number of citations is 2, because The same variable container is associated with variable a and variable b. PHP will not copy the generated variable container when it is not necessary. The variable container is destroyed when "refcount" becomes 0. When anything associated with a variable is easy When the variable leaves its scope (for example: the function execution ends), or the unset() function is called on the variable, the "refcount" will be reduced by 1. The following example can illustrate:
<?php $a = "new string"; $b = $c = $a; xdebug_debug_zval('a'); unset($b, $c); xdebug_debug_zval('a'); ?>
The above code will output:
a: (refcount=3, is_ref=0)='new string' a: (refcount=1, is_ref=0)='new string'If we execute unset($a) now, $ contains This container of types and values is removed from memory
Compound types
When considering compound types like array and object, things are slightly It's a bit complicated. Unlike scalar type values, array and object type variables store their members or properties in their own symbol tables. This means that the following example will generate three zval variable containers<?php $a = array('meaning' => 'life', 'number' => 42); xdebug_debug_zval('a'); ?>
以上代码输出:
a: (refcount=1, is_ref=0)=array ('meaning' => (refcount=1, is_ref=0)='life', 'number' => (refcount=1, is_ref=0)=42)
这三个zval变量容器是:a,meaning,number.增加和减少refcount的规则和上面提到的一样
特例,添加数组本身作为数组元素时:
<?php $a = array('one'); $a[] = &$a; xdebug_debug_zval('a'); ?>
以上代码输出的结果:
a: (refcount=2, is_ref=1)=array (0 => (refcount=1, is_ref=0)='one', 1 => (refcount=2, is_ref=1)=...)
可以看到数组a和数组本身元素a[1]指向的变量容器refcount为2
当对数组$a调用unset函数时,$a的refcount变为1,发生了内存泄漏
清理变量容器的问题
尽管不再有某个作用域中的任何符号指向这个结构(就是变量容器),由于数组元素"1"仍然指向数组本身,所以这个容器不能被消除.因为没有另外的符号指向它,用户没有办法清除这个结构,结果就会导致内存泄漏.庆幸的是,php将在请求结束时清除这个数据结构,但是php清除前,将耗费不少内存空间
回收周期
5.3.0PHP使用了新的同步周期回收算法,来处理上面所说的内存泄漏问题
首先,我们先要建立一些基本规则:
如果一个引用计数增加,它将继续被使用,当然就不再垃圾中.如果引用技术减少到零,所在的变量容器将被清除(free).就是说,仅仅在引用计数减少到非零值时,才会产生垃圾周期(grabage cycle).其次,在一个垃圾周期中,通过检查引用计数是否减1,并且检查哪些变量容器的引用次数是零,来发现哪部分是垃圾
为避免不得不检查所有引用计数可能减少的垃圾周期,这个算法把所有可能根(possible roots 都是zval变量容器),放在根缓冲区(root buffer)中(用紫色标记),这样可以同时确保每个可能的垃圾根(possible garbage root)在缓冲区只出现一次.仅仅在根缓冲区满了时,才对缓冲区内部所有不同的变量容器执行垃圾回收操作。
相关推荐：
The above is the detailed content of Detailed explanation of GC mechanism in PHP. For more information, please follow other related articles on the PHP Chinese website!