Memory overflow when PHP objects refer to each other_PHP Tutorial

One of the biggest benefits of using a scripting language is that you can take advantage of its automatic garbage collection mechanism (release memory). You don't need to do any processing to release the memory after using the variable, PHP will do it for you.
Of course, we can call the unset() function to free the memory if we want, but usually there is no need to do so.
However, in PHP, there is at least one situation where the memory will not be automatically released, even if unset() is called manually. Details can be found at: http://bugs.php.net/bug.php?id=33595.

Problem Symptoms
If there is a mutual reference relationship between two objects, such as "parent object-child object", calling unset() on the parent object will not release the memory that references the parent object in the child object ( Not even if the parent object is garbage collected).
A little confused? Let’s take a look at the following code:

bar = new Bar($this);}}class Bar {function __construct($foo = null){$this->foo = $ foo;}}while (true) {$foo = new Foo();unset($foo);echo number_format(memory_get_usage()) . " ";}?>Run this code and you will see the memory usage getting higher and higher until it is used up.

...33,551,61633,551,97633,552,33633,552,696PHP Fatal error: Allowed memory size of 33554432 bytes exhausted(tried to allocate 16 bytes) in memleak.php on line 17 For most PHP programmers This situation is not a problem.
But if you use a lot of objects that reference each other in a long-running code, especially if the objects are relatively large, the memory will be consumed quickly.

Userland Solution
Although a bit tedious and inelegant, there is a solution provided in the bugs.php.net link mentioned earlier.
This solution uses a destructor method before releasing the object to achieve the purpose. The Destructor method can clear all internal parent object references, which means that this part of the memory that would otherwise overflow can be released.
Here’s the “after” code:

bar = new Bar($this);}function __destruct(){unset($this->bar);}}class Bar {function __construct($foo = null){$this->foo = $foo;}}while (true) {$foo = new Foo();$foo->__destruct();unset($foo);echo number_format (memory_get_usage()) . " ";}?>Note the new Foo::__destruct() method and the call to $foo->__destruct() before releasing the object. Now this code solves the problem of increasing memory usage. In this way, the code will work well

.

PHP kernel solution?
Why does memory overflow occur? I'm not proficient in PHP kernel research, but I'm sure this problem is related to reference counting.
The reference count of $foo referenced in $bar will not be decremented because the parent object $foo is released. At this time, PHP thinks that you still need the $foo object, so this part of the memory will not be released...probably like this .
My ignorance really shows here, but the general idea is: a reference count is not decremented, so some memory is never freed.
In the aforementioned bugs.php.net link I read that modifying the garbage collection process would sacrifice huge performance, and since I don't know much about reference counting, I assumed this was true.
Instead of changing the garbage collection process, why not use unset() to release the internal objects? (Or call __destruct() when releasing the object?)
Perhaps PHP kernel developers can make changes to this garbage collection mechanism here or elsewhere.
Update: Martin Fjordvald mentioned in the comments a patch written by David Wang for garbage collection (actually it looks more like "a whole piece of cloth" - very huge. See the CVS export information at the end of this email for details .) does exist (an email) and has received attention from PHP kernel development members. The question is whether this patch should be put into PHP5.3 and it has not received much support. I think a good compromise is to call the __destruct() method in the object in the unset() function;

http://www.bkjia.com/PHPjc/508217.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/508217.htmlTechArticleOne of the biggest benefits of using a scripting language is that you can take advantage of its automatic garbage collection mechanism (release memory). You don't need to do anything to release the memory after using the variable, PHP will...