PHP reference counting memory management mechanism and garbage collection mechanism

This article shares with you the reference counting memory management mechanism and garbage collection mechanism of PHP. Friends who need help can refer to it

Reference assignment

$a = 'apple';
$b = &$a;

Above In the code, I assign a string to variable a, and then assign the reference of a to variable b. Obviously, the memory pointing at this time should be like this:

$a -> 'apple' <- $b

a and b point to the same memory area (variable container zval), we pass var_dump($a, $b) gets string(5) "apple" string(5) "apple" , which is what we expected.

unset function and reference counting

unset function

Suppose I want to release the string 'apple' from memory. This is what I did:

unset($a);

But by printing the information of the two variables $a $b again, I got this result: Notice: Undefined variable : a and string(5) "apple" . Strange, $a $b points to the same variable container, and $a is clearly released, why $b is still 'apple'.

Actually, unset() only destroys a variable symbol a (pointer) and does not release the variable container, so after the operation is completed , the memory pointer just becomes like this:

'apple' <- $b

Reference count

The reference count (reference count) is a piece of information stored in each variable container. It indicates how much the current variable container is being used. referenced by variable symbols.

As in the previous example, unset() does not release the variable container pointed by the variable, but only destroys the variable symbol. At the same time, reduce the reference count in the variable container by 1. When the reference count is 0, that is to say, when the variable container is not referenced by any variable, will trigger PHP's garbage collection (error ), it will be released (correct).

Correction of the above minor error: This simple reference counting method is the memory management mechanism before PHP 5.2. It cannot be called a garbage collection mechanism. The garbage collection mechanism was only introduced in PHP 5.3. The garbage collection mechanism is to solve the shortcomings of this simple reference counting memory management mechanism (that is, memory leaks caused by circular references, which will be explained below)

Back to the topic, we use code to verify Let’s look at the previous conclusion:

$a = 'apple';
$b = &$a;

$before = memory_get_usage();
unset($a);
$after = memory_get_usage();

var_dump($before - $after);  // 结果为int(0)，变量容器的引用计数为1，没有释放

$a = 'apple';
$b = &$a;

$before = memory_get_usage();
unset($a, $b);
$after = memory_get_usage();

var_dump($before - $after);  // 结果为int(24)，变量容器的引用计数为0，得到释放

Directly release

So what can we do to really release the memory occupied by 'apple'?

Using the above method, we can unset($a) and then unset($b) to destroy all references to the variable container and decrement the reference count. If it is 0, it will naturally be released.

Of course, there is a more direct method:

$a = null;

Direct assignment null will empty the memory area pointed to by $a and The reference count returns to zero and the memory is released.

Memory after script execution ends

For general web programs (in fpm mode), PHP execution is single-thread synchronous blocking type. After the script execution ends, the script All memory used will be released. So, does it make sense for us to manually release the memory?

In fact, this question has been answered for a long time. I recommend everyone to read an article published by @laruence in 2012:

Please release resources manually

Defects of the reference counting memory management mechanism: circular references

Now let’s talk about the flaws of the reference counting memory management mechanism mentioned before.

When the reference count of a variable container is 0, PHP will perform garbage collection. However, have you ever thought about it, there is a situation that will cause the reference count of a variable container to never be reduced to 0. For example:

$a = ['one'];
$a[] = &$a;

We see that the $a array The two elements are themselves. Then, the reference count of the variable container storing the array is 2, one reference is the variable a, and the other reference is the second element of the array - index 1.

So, if we unset($a) at this time, the reference count of the variable container storing the array will be reduced by 1 , but there is still one reference, which is the element 1 of the array. Now the reference structure becomes like this:

##Because The reference count of the variable container has not changed to 0, so it cannot be released, and there are no other external variable symbols referencing it at this time. The user has no way to clear this structure, and it will always reside in the memory.

So if there are a large number of such structures and operations in the code, it will eventually lead to memory loss or even leaks. This is the problem of memory being unable to be released caused by

Circular Reference.

Fortunately, in fpm mode, when the execution of the requested script ends, PHP will release all memory used in the script, including this structure. However, what if it is a php program under the daemon process? Such as swoole. Urgent problems that need to be solved in this php (already solved, see below).

Synchronization algorithm introduced in PHP 5.3.0

Traditionally, the reference counting memory mechanism used by PHP in the past cannot handle memory leaks of circular references. However, the synchronization algorithm in the 5.3.0 PHP usage article » Concurrent Cycle Collection in Reference Counted Systems solves this memory leak problem. This algorithm is PHP's garbage collection mechanism.

The implementation and process of the specific algorithm are a bit complicated. Please read the official documentation. I will not go into details here. I also attach several links to articles explaining the algorithm process, which are relatively straightforward:

http://php.net/manual/zh/feat... Official documentation
http://www.cnblogs.com/leoo2s...
https://blog.csdn.net/phpkern. ..

Finally, let me quote these two paragraphs from Niao Ge’s article to illustrate the problem:

Before PHP5.2, PHP used reference count for resource management. When a When the reference count of zval reaches 0, it will be released. Although there is a cycle reference, this design is not a problem for developing Web scripts, because the characteristics of Web scripts and its goal are to execute The time is short and will not run for a long time. Resource leaks caused by circular references will be released at the end of the request. In other words, releasing resources at the end of the request is a remedial measure (backup).

However, as PHP is used by more and more people, and many people use PHP in some background scripts. These scripts are characterized by long-term running. If there are circular references, causing the reference count to be unable to release unused resources in time, the script will eventually run out of memory. Exit when exhausted.

So after PHP5.3, we introduced GC. In other words, we introduced GC to solve problems that users cannot solve.

The above is the detailed content of PHP reference counting memory management mechanism and garbage collection mechanism. For more information, please follow other related articles on the PHP Chinese website!