Example analysis of memory overflow when PHP objects refer to each other, PHP example analysis_PHP tutorial

Analysis of memory overflow instances where PHP objects refer to each other, php instance analysis

Generally speaking, one of the biggest benefits of using a scripting language is that you can use its automatic garbage collection mechanism to free up memory. You don't need to do anything to release the memory after using the variables, because PHP will do it for you.
Of course, we can call the unset() function to free the memory if we wish, but this is usually not necessary.
However, in PHP, there is at least one situation where memory will not be automatically released, even if unset() is called manually. For details, please refer to the analysis of memory leaks on the PHP official website: http://bugs.php.net/bug.php?id=33595.

The symptoms of the problem are as follows:

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 Not even recycling).

Are you a little confused? Let’s take a look at the following code:

<&#63;
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()) . " ";
}
&#63;>

Run this code and you will see the memory usage getting higher and higher until it runs out.

...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 exhausted 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 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’s the “after” code:

<&#63;
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()) . " ";
}
&#63;>

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 and will not release this part of the memory. The principle is roughly the same.

In layman’s terms, the general meaning is: a reference count is not decremented, so some memory will never be released.
In addition, the bugs.php.net link mentioned earlier points out that modifying the garbage collection process will sacrifice great performance, and readers need to pay attention to this.

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.

I believe that what is described in this article will be helpful for everyone to deeply understand the operating principles of PHP.

How are multi-level references to PHP objects referenced?

class Fruit{
protected $con = array();

function aa(){
$this->con[0] = new Apple();
$ this->con[1] = new Banana();
echo $this->con[0]->sweet;
}
}

How to check what object resources are referenced or occupied in android memory overflow

Try changing the reference of the suspicious object to a weak reference. Weak references can solve the problem of memory overflow

http://www.bkjia.com/PHPjc/871098.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/871098.htmlTechArticleAnalysis of memory overflow instances when PHP objects refer to each other. PHP instance analysis is generally one of the biggest benefits of using scripting languages. You can use its automatic garbage collection mechanism to release memory...