One of the biggest benefits of using a scripting language is that you can take advantage of its automatic garbage collection mechanism (freeing 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 referencing the parent object in the child object (even if the parent object is garbage collected , also doesn’t work).
A little confused? Let's look at the following code:
<?phpclass Foo {function __construct(){$this->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()) . "n";}?>Run this code and you will see The memory usage gets 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 is 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 exhausted quickly.
The Userland solution is somewhat tedious and inelegant, but the bugs.php.net link mentioned earlier provides a solution.
This solution uses a destructor method before releasing the object to achieve this goal. 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 is the "after fix" code:
<?phpclass Foo {function __construct(){$this->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()) . "n";}?>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, so the code can 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... or so.
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 saw 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 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.) Indeed exists (an email) and has received attention from members of the PHP kernel development community. 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;