(Recommended tutorial: PHP video tutorial)
Every php Variables are stored in a variable container called zval.
A zval variable container, in addition to containing the type and value of the variable, 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 the reference collection. Through this byte, the PHP engine can distinguish ordinary variables from reference variables. 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 number of variables pointing to this zval variable container.
All symbols exist in a symbol table, in which each symbol has a scope, as do the main scripts (for example: scripts requested through the browser) and each function or method. Scope.
When a variable is assigned a constant value, a zval variable container will be generated
If Xdebug is installed, you can use xdebug_debug_zval() Check these two
<?php $a = "new string"; xdebug_debug_zval('a'); //结果 a: (refcount=1, is_ref=0)='new string'
Assigning one variable to another variable will increase the number of references
<?php $a = "new string"; $b = $a; xdebug_debug_zval( 'a' ); //结果 a: (refcount=2, is_ref=0)='new string'
Use unset() to reduce the number of references
The variable container containing the type and value will be deleted from the memory
<?php $a = "new string"; $c = $b = $a; xdebug_debug_zval( 'a' ); unset( $b, $c ); xdebug_debug_zval( 'a' ); //结果 a: (refcount=3, is_ref=0)='new string' a: (refcount=1, is_ref=0)='new string'
<?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 )
Add an existing element to the array
<?php $a = array( 'meaning' => 'life', 'number' => 42 ); $a['life'] = $a['meaning']; xdebug_debug_zval( 'a' ); //结果 a: (refcount=1, is_ref=0)=array ( 'meaning' => (refcount=2, is_ref=0)='life', 'number' => (refcount=1, is_ref=0)=42, 'life' => (refcount=2, is_ref=0)='life' )
Delete An element in the array
is similar to deleting a variable from the scope.
After deletion, the "refcount" value of the container where the element in the array is located is reduced
<?php $a = array( 'meaning' => 'life', 'number' => 42 ); $a['life'] = $a['meaning']; unset( $a['meaning'], $a['number'] ); xdebug_debug_zval( 'a' ); //结果 a: (refcount=1, is_ref=0)=array ( 'life' => (refcount=1, is_ref=0)='life' )
When we add an array itself as an element of this array, things get interesting
Same as above, calling unset on a variable will delete the symbol, and The number of references in the variable container it points to is also reduced by 1
<?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)=... )
Although it is no longer in a certain scope Any symbol points to this structure (that is, the variable container). Since the array element "1" still points to the array itself, this container cannot be cleared.
Because there is no other symbol pointing to it, the user has no way to clear this structure, which will result in a memory leak.
Fortunately, PHP will clear this data structure at the end of script execution, but before PHP clears it, it will consume a lot of memory.
It’s okay if the above situation occurs only once or twice, but if memory leaks occur thousands or even hundreds of thousands of times, this is obviously a big problem
The reference counting memory mechanism used by PHP in the past cannot handle circular reference memory leaks
In PHP 5.3.0, a synchronization algorithm is used to deal with this memory leak problem
If a reference count is increased, it will continue to be used and of course no longer in the garbage.
If the reference count is reduced to zero, the variable container will be cleared (free)
That is to say, a garbage cycle will only occur when the reference count is reduced to a non-zero value
In a garbage cycle, find out which part is garbage by checking whether the reference count is reduced by 1 and checking which variable containers have zero references.
In order to avoid having to check all reference counts, the garbage cycle may be reduced
This algorithm puts all possible roots (possible roots are zval variable containers) in the root buffer (marked with purple, called suspected garbage), so that every possible garbage can be ensured at the same time The root (possible garbage root) appears only once in the buffer. Garbage collection is performed on all different variable containers within the buffer only when the root buffer is full. Look at step A in the image above.
In step B, simulate deleting each purple variable. When simulating deletion, the reference count of ordinary variables that are not purple may be reduced by "1". If the reference count of an ordinary variable becomes 0, simulate deletion of this ordinary variable again. Each variable can only be simulated deleted once, and is marked gray after simulated deletion
In step C, the simulation restores each purple variable. Recovery is conditional. When the reference count of the variable is greater than 0, simulated recovery is performed. Similarly, each variable can only be restored once. After restoration, it is marked as black. It is basically the inverse operation of step B. In this way, the remaining pile of unrecoverable blue nodes are the blue nodes that should be deleted. Traverse them in step D and really delete them
There are two main ones Domains have an impact on performance
The first is the saving of memory space
The other is the increase in the time it takes for the garbage collection mechanism to release leaked memory
The garbage collection mechanism in PHP will only increase the time consumption when the recycling algorithm is actually running. But in normal (smaller) scripts there should be no performance impact at all.
However, in the case of normal scripts with recycling mechanisms running, the memory savings will allow more such scripts to run on your server at the same time. Because the total memory used has not reached the upper limit.
This benefit is especially obvious in long-running scripts, such as long-running test suites or daemon scripts.
(Recommended tutorial: PHP video tutorial)
The above is the detailed content of Learn more about PHP's garbage collection mechanism. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
