Learn more about PHP's garbage collection mechanism

This article brings you relevant knowledge about PHP. It mainly introduces the PHP garbage collection mechanism. Through a brief case, it explains the principle and use of this mechanism in detail. The following is the details Content, friends in need can refer to it.

(Recommended tutorial: PHP video tutorial)

1. Basic knowledge of reference counting

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.

2. Generate zval container

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(&#39;a&#39;);
 
//结果
a: (refcount=1, is_ref=0)=&#39;new string&#39;

3. Increase the reference count of zval

Assigning one variable to another variable will increase the number of references

<?php
$a = "new string";
$b = $a;
xdebug_debug_zval( &#39;a&#39; );
 
//结果
a: (refcount=2, is_ref=0)=&#39;new string&#39;

4. Reduce the reference count of zval

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( &#39;a&#39; );
unset( $b, $c );
xdebug_debug_zval( &#39;a&#39; );
 
//结果
a: (refcount=3, is_ref=0)=&#39;new string&#39;
a: (refcount=1, is_ref=0)=&#39;new string&#39;

5. Composite type zval container

• Different from scalar type values
• array and object type variables store their members or attributes in their own symbol tables
• This means the following The example will generate three zval variable containers
• The three zval variable containers are: a, meaning and number

<?php
$a = array( &#39;meaning&#39; => &#39;life&#39;, &#39;number&#39; => 42 );
xdebug_debug_zval( &#39;a&#39; );
 
//结果
a: (refcount=1, is_ref=0)=array (
   &#39;meaning&#39; => (refcount=1, is_ref=0)=&#39;life&#39;,
   &#39;number&#39; => (refcount=1, is_ref=0)=42
)

6. Add compound Reference count of the type

Add an existing element to the array

<?php
$a = array( &#39;meaning&#39; => &#39;life&#39;, &#39;number&#39; => 42 );
$a[&#39;life&#39;] = $a[&#39;meaning&#39;];
xdebug_debug_zval( &#39;a&#39; );
 
//结果
a: (refcount=1, is_ref=0)=array (
   &#39;meaning&#39; => (refcount=2, is_ref=0)=&#39;life&#39;,
   &#39;number&#39; => (refcount=1, is_ref=0)=42,
   &#39;life&#39; => (refcount=2, is_ref=0)=&#39;life&#39;
)

7. Decrease the reference count of the composite type

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( &#39;meaning&#39; => &#39;life&#39;, &#39;number&#39; => 42 );
$a[&#39;life&#39;] = $a[&#39;meaning&#39;];
unset( $a[&#39;meaning&#39;], $a[&#39;number&#39;] );
xdebug_debug_zval( &#39;a&#39; );
 
//结果
a: (refcount=1, is_ref=0)=array (
   &#39;life&#39; => (refcount=1, is_ref=0)=&#39;life&#39;
)

8. Special cases

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( &#39;one&#39; );
$a[] = &$a;
xdebug_debug_zval( &#39;a&#39; );
 
//结果
a: (refcount=2, is_ref=1)=array (
   0 => (refcount=1, is_ref=0)=&#39;one&#39;,
   1 => (refcount=2, is_ref=1)=...
)

9. The problem of cleaning up the variable container

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

10. Recycling Cycle

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.

ten 1. Analysis of recycling algorithm

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

12. Performance considerations

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

13. Conclusion of the garbage collection mechanism

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!