Problems using unset to destroy variables and release memory in PHP_PHP Tutorial

Copy code The code is as follows:

for ( $i = 1; $i $ str = str_repeat('01234567', $i);
$a = memory_get_usage();
unset($str);
$b = memory_get_usage();
echo "n
".$i.': '.($b - $a).' Bytes.';
}

From the result:
8 x 32 = 256 in 256 It is really necessary to release the memory when the bytes are long. Some people say that it is faster than direct $str = null.
The results are as follows:
1: 0 Bytes.
2: 0 Bytes.
3: 0 Bytes.
4: 0 Bytes.
5: 0 Bytes.
6 : 0 Bytes.
7: 0 Bytes.
8: 0 Bytes.
9: 0 Bytes.
10: 0 Bytes.
11: 0 Bytes.
12: 0 Bytes.
13: 0 Bytes.
14: 0 Bytes.
15: 0 Bytes.
16: 0 Bytes.
17: 0 Bytes.
18: 0 Bytes.
19: 0 Bytes.
20: 0 Bytes.
21: 0 Bytes.
22: 0 Bytes.
23: 0 Bytes.
24: 0 Bytes.
25: 0 Bytes.
26: 0 Bytes.
27: 0 Bytes.
28: 0 Bytes.
29: 0 Bytes.
30: 0 Bytes.
31 : 0 Bytes.
32: -272 Bytes.
33: -280 Bytes.
34: -288 Bytes.
35: -296 Bytes.
36: -304 Bytes.
37: -312 Bytes.
38: -320 Bytes.
39: -328 Bytes.
40: -336 Bytes.
41: -344 Bytes.
42: - 352 Bytes.
43: -360 Bytes.
44: -368 Bytes.
45: -376 Bytes.
46: -384 Bytes.
47: -392 Bytes.
48: -400 Bytes.
49: -408 Bytes.
50: -416 Bytes.
51: -424 Bytes.
52: -432 Bytes.
53: -440 Bytes.
54: -448 Bytes.
55: -456 Bytes.
56: -464 Bytes.
57: -472 Bytes.
58: -480 Bytes.
59: -488 Bytes.
60: -496 Bytes.
61: -504 Bytes.
62: -512 Bytes.
63: -520 Bytes.
64: -528 Bytes .
65: -536 Bytes.
66: -544 Bytes.
67: -552 Bytes.
68: -560 Bytes.
69: -568 Bytes.
70 : -576 Bytes.
71: -584 Bytes.
72: -592 Bytes.
73: -600 Bytes.
74: -608 Bytes.
75: -616 Bytes.
76: -624 Bytes.
77: -632 Bytes.
78: -640 Bytes.
79: -648 Bytes.
80: -656 Bytes.
81: -664 Bytes.
82: -672 Bytes.
83: -680 Bytes.
84: -688 Bytes.
85: -696 Bytes.
86: -704 Bytes.
87: -712 Bytes.
88: -720 Bytes.
89: -728 Bytes.
90: -736 Bytes.
91: -744 Bytes.
92: - 752 Bytes.
93: -760 Bytes.
94: -768 Bytes.
95: -776 Bytes.
96: -784 Bytes.
97: -792 Bytes.
98: -800 Bytes.
99: -808 Bytes.

Let’s look at an example first

Copy the code The code is as follows:

$s=str_repeat('1',255); //Generate a string consisting of 255 ones
$m=memory_get_usage(); / /Get the currently occupied memory
unset($s);
$mm=memory_get_usage(); //Check the currently occupied memory after unset()
echo $m-$mm;
?> ;

Finally output the memory occupied before unset() minus the memory occupied after unset(). If it is a positive number, it means that unset($s) has destroyed $s from the memory (or in other words, The memory usage decreased after unset()), but under PHP5 and windows platforms, the result I got was: -48. Does this mean that unset($s) does not destroy the memory occupied by variable $s? Let’s take the following example:

Copy code The code is as follows:

$s=str_repeat ('1',256); //Generate a string consisting of 256 ones
$m=memory_get_usage(); //Get the currently occupied memory
unset($s);
$mm= memory_get_usage(); //Check the currently occupied memory after unset()
echo $m-$mm;
?>

This example is almost the same as the above example. The only difference is that $s consists of 256 1's, which is one more 1 than the first example, and the result is: 224. Does this mean that unset($s) has destroyed the memory occupied by $s?
Through the above two examples, we can draw the following conclusions: Conclusion 1. The unset() function can only release the memory space when the variable value occupies more than 256 bytes of memory space.
So as long as the variable value exceeds 256, can using unset free up memory space? Let’s test it with another example:

Copy the code The code is as follows:

$s =str_repeat('1',256); //This is exactly the same as the second example
$p=&$s;
$m=memory_get_usage();
unset($s); / /destroy $s
$mm=memory_get_usage();
echo $p.'
';
echo $m-$mm;
?>

' Refreshing the page, we see that the first line has 256 1s, and the second line is -48. It stands to reason that we have destroyed $s, and $p is just a variable that refers to $s, and there should be no content. In addition, the memory usage after unset($s) has increased compared with before unset()! Now let’s do the following example:

Copy the code The code is as follows:

$s= str_repeat('1',256); //This is exactly the same as the second example
$p=&$s;
$m=memory_get_usage();
$s=null; //Set $s is null
$mm=memory_get_usage();
echo $p.'
';
echo $m-$mm;
?>

Now refresh the page. We see that the output $p has no content. The difference in memory usage before and after unset() is 224, that is, the memory occupied by the variable has been cleared. $s=null in this example can also be replaced by unset(), as follows:

Copy code The code is as follows:

$s=str_repeat('1',256); //This is exactly the same as the second example
$p=&$s;
$m=memory_get_usage();
unset($s); //Destroy $s
unset($p);
$mm=memory_get_usage();
echo $p.'
';
echo $m-$mm;
?>

We destroy both $s and $p using unset(). At this time, the difference in memory usage is also 224, indicating that This also frees up memory. Then, we can get another conclusion: Conclusion 2. The memory will be released only when all variables (such as reference variables) pointing to the variable are destroyed.
I believe that after the examples in this article, everyone should have an understanding of unset(). At the very least, I use unset() to release memory when the variable does not work.

http://www.bkjia.com/PHPjc/325687.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/325687.htmlTechArticleCopy the code code as follows: for ( $i = 1; $i 100; $i++ ) { $str = str_repeat ('01234567', $i); $a = memory_get_usage(); unset($str); $b = memory_get_usage(); echo "n ".$i.': '.($b -...