PHP memory overflow allowed memories size of solution

PHP appears with the following error: Allowed memory size of xxx bytes exhausted at xxx:xxx (tried to allocate xxx bytes)
In this regard, this site, http://nodonkey.iteye.com/blog/728223 has been described.
At the same time, there are http://hi.baidu.com/thinkinginlamp/blog/item/e400f819a3caab7cdbb4bd4e.html this article is also about this issue.
Why do we all say, here also to say, is not superfluous? Not really. The English text of this question is in: http://paul-m-jones.com/archives/262
As can be seen, it is necessary to summarize again.

If there is a recursive reference to the PHP object, a memory leak occurs. This bug has been around for a long time in PHP, so let's start by reproducing the bug:

PHP code

2. <?php
4. Class Foo {
6. function __construct () {
8. $this->bar = new bar ($this);
10. }
12. }
16. Class Bar {
18. function __construct ($foo) {
20. $this->foo = $foo;
22. }
24. }
28. for ($i = 0; $i < 100; $i + +) {  
30. $obj = new Foo ();
34. unset ($obj);
38. Echo memory_get_usage (), "\ n";
40. }
42. ?>

Run the above code, you will find that the memory usage should have been the same, but in fact it is constantly increasing, unset not fully effective.
As we can see, the method given in the original English language is to call destructors manually. Why did you do it?
We give a new code, and note that the comments in the code explain the problem:

PHP code

2. <?php
4. Class Foo {
6. function __construct () {
8. //php5.3 Previous version, it is an elixir of immortality.  Because it was created, it references itself.
10. //In fact, this class and the class referencing it cannot be unset as long as the class is referenced in the property of any of the external objects.
12. //This is where we made a mistake here.
14. $this->bar = new bar ($this);
16. }
18. function __destruct () {
20. Echo (' Foo die--3--<br> ');
22. unset ($this->bar);
24. }
26. /** 
28. * Because we made a mistake here, we're here to clean up the mess. So, add a corpse function
30. * This approach, that is, do not call __destruct outside, it looks very unsightly.
32. * But adding this function has a big advantage. is to show the user that we need to kill it on our own initiative. Instead of waiting for it to die automatically.
34. * If you don't want to, you can call __destruct directly outside
36. */
38. function Destroy ()
40. {
42. Echo (' destroy--1--<br> ');
44. unset ($this->bar);
46. }
48. }
52. Class Bar {
54. function __construct ($foo) {
56. $this->foo = $foo;
58. }
62. function __destruct () {
64. Echo (' Bar die--2--<br> ');
66. }
68. }
72. for ($i = 0; $i < 100; $i + +) {  
74. Echo memory_get_usage (), "<br>";
76. $obj = new Foo ();
78. //Comment out, or let go of the line below the note and run it.  The results were later in this article.
80. //We can find that if we do not bury the corpse, then PHP actively calls __destruct, then it is executed at the end of the program.
82. //If we take the initiative, we can release the memory in time.
84. $obj->destroy ();
86. unset ($obj);
88. }
90. Echo Memory_get_usage (), "<br>";
92. ?>

    We can find that when we comment out 42 lines in the above code [$obj->destroy ();] , the call in __destruct was delayed by PHP. That is, if the PHP object has recursive references, PHP does not release the memory in time. Even if you use unset, it is useless to want to force the release.
    We quote partial run results:
99616
99984
100352
100720
101088
Foo die--3--
Bar die--2- -
foo die--3--
Bar die--2--
Foo die--3--
Bar die--2--
Foo die--3--
Bar die--2--
Foo die--3--bar die--2--
    It can be seen that Foo,bar died at the end of the program, and that Foo died first and Bar died. This is because PHP is clear and you don't need them anymore.
    Once we manually invoke [$obj->destroy ();], because recursive references to PHP objects have been corrupted, unset works.
    We quote a partial run result:
64256
Destroy--1--
Bar die--2--
Foo die--3--
65008
Destroy-- *
Bar die--2--
foo die--3--
65008
Destroy--1--
Bar die--2--
Foo die--3--
    As you can see, Foo,bar is dead immediately after you call destroy, and memory is no longer growing.
    This bug is said to have been resolved in php5.3. If you are in php5.3, you can call gc_collect_cycles this function manually.
    If so, there is no difference between the fact that you manually add destroy to the class and let the user call.

Recursive references are often used. In particular, build a tree structure object with PHP. Note the link in the user comment in the original English text: http://www.alexatnet.com/node/73
The code given here:

PHP code

2. Class Node {
4. public $parentNode;
6. public $childNodes = Array ();
8. function Node () {
10. $this->nodevalue = str_repeat (' 0123456789 ', 128);
12. }
14. }
16. function CreateRelationship () {
18. $parent = new Node ();
20. $child = new Node ();
22. $parent->childnodes[] = $child;
24. $child->parentnode = $parent;
26. }
28. And then let's review the amount of memory allocated by this script after a calls to CreateRelationship function.
30. Echo ' Initial: '. Number_format (Memory_get_usage (), 0, '. ', ', ' ).    "bytes\n";
32. for ($i = 0; $i < 10000; $i + +) {    
34. CreateRelationship ();
36. }
38. Echo ' Peak: '. Number_format (Memory_get_peak_usage (), 0, '. ', ', ' ).    "bytes\n";
40. Echo ' End: '. Number_format (Memory_get_usage (), 0, '. ', ', ' ).   "bytes\n";

The output is:

initial:327,336 bytes
peak:35,824,176 bytes
end:35,823,328 bytes

The way the authors suggest is to increase the Destroy method,

PHP code

2. Class Node {
4. public $parentNode;
6. public $childNodes = Array ();
8. function Node () {
10. $this->nodevalue = str_repeat (' 0123456789 ', 128);
12. }
14. function Destroy ()
16. {
18. $this->parentnode = null;
20. $this->childnodes = Array ();
22. }
24. }
28. function CreateRelationship () {
30. $parent = new Node ();
32. $child = new Node ();
34. $parent->childnodes[] = $child;
36. $child->parentnode = $parent;
38. $parent->destroy ();
40. }

In addition, the author also gives the solution in php5.3: Using the new function in php5.3, call gc_collect_cycles this function manually.

PHP code

1. function CreateRelationship () {
2. $parent = new Node ();
3. $child = new Node ();
4. $parent->childnodes[] = $child;
5. $child->parentnode = $parent;
6. Gc_collect_cycles ();
7. }

At the same time, the author also tells us, call Gc_collect_cycles This function, we do not need to add additional destroy, but there are some drawbacks in performance.

We can also make further improvements to the code. That is to change to a static function. Specific as follows:

PHP code

2. <?php
4. Class Foo {
6. function __construct () {
8. //php5.3 Previous version, it is an elixir of immortality.  Because it was created, it references itself.
10. //In fact, this class and the class referencing it cannot be unset as long as the class is referenced in the property of any of the external objects.
12. //This is where we made a mistake here.
14. $this->bar = new bar ($this);
16. }
18. function __destruct () {
20. Echo (' Foo die--3--<br> ');
22. unset ($this->bar);
24. }
26. /** 
28. * Because we made a mistake here, we're here to clean up the mess. So, add a corpse function
30. * This approach, that is, do not call __destruct outside, it looks very unsightly.
32. * But adding this function has a big advantage. is to show the user that we need to kill it on our own initiative. Instead of waiting for it to die automatically.
34. * If you don't want to, you can call __destruct directly outside
36. * In fact, after doing this, there is no need to clean up the memory, write two lines of code, one line of code is enough.
38. */
40. static function Destroy ($obj)
42. {
44. Echo (' destroy--1--<br> ');
46. unset ($obj->bar);
48. unset ($obj);
50. }
52. }
56. Class Bar {
58. function __construct ($foo) {
60. $this->foo = $foo;
62. }
66. function __destruct () {
68. Echo (' Bar die--2--<br> ');
70. }
72. }
76. for ($i = 0; $i < 100; $i + +) {  
78. Echo memory_get_usage (), "<br>";
80. $obj = new Foo ();
82. //Use a static function instead, just one line here.
84. Foo::d Estroy ($obj);
88. }
90. Echo Memory_get_usage (), "<br>";
92. ?>

PHP memory overflow allowed memories size of solution