How does PHP destroy expired variables and release the memory? Unset usage

Let's first look at an example:

The code is as follows:	Copy code
<? Php $ S = str_repeat ('1', 255); // generates a string consisting of 255 1 $ M = memory_get_usage (); // Get the memory occupied currently Unset ($ s ); $ Mm = memory_get_usage (); // unset () and check the memory occupied. Echo $ m-$ mm; ?>

Finally, the output unset () occupies memory minus unset () and then occupies memory. If it is a positive number, it indicates that unset ($ s) has destroyed $ s from memory (or, after unset (), the memory usage is reduced. However, on the PHP5 and windows platforms, the result is-48. Does this indicate that unset ($ s) does not destroy the memory occupied by the variable $ s? Let's take the following example:

The code is as follows:	Copy code
<? Php $ S = str_repeat ('1', 256); // generates a string consisting of 256 1 $ M = memory_get_usage (); // Get the memory occupied currently Unset ($ s ); $ Mm = memory_get_usage (); // unset () and check the memory occupied. Echo $ m-$ mm; ?>

In this example, it is almost the same as the preceding example. The only difference is that $ s is composed of 256 1 s, that is, one more than the first example. The result is 224. Does this indicate 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.

Is it possible to use unset to release memory space as long as the variable value exceeds 256? Let's test it through an example:

The code is as follows:	Copy code
<? Php $ 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. '<br/> '; Echo $ m-$ mm; ?>

Refresh the page and we can see that there are 256 1 in the first line and-48 in the second line. We have destroyed $ s, and $ p just references the $ s variable, there should be no content. In addition, the memory usage after unset ($ s) is higher than that before unset! Now let's take the following example:

The code is as follows:	Copy code
<? Php $ S = str_repeat ('1', 256); // This is exactly the same as the second example. $ P = & $ s; $ M = memory_get_usage (); $ S = null; // Set $ s to null. $ Mm = memory_get_usage (); Echo $ p. '<br/> '; Echo $ m-$ mm; ?>

Refresh the page and we can see that the output $ p has no content. The difference between memory usage and unset () is 224, that is, the memory occupied by variables has been cleared. In this example, $ s = null can also be replaced with unset (), as follows:

The code is as follows:	Copy code
<? Php $ 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. '<br/> '; Echo $ m-$ mm; ?>

We will use unset () to destroy both $ s and $ p. Then we can see that the memory usage difference is also 224, which means the memory can be released. Therefore, we can draw another conclusion: Conclusion 2: The memory will be released only when all the variables pointing to this variable (such as the referenced variables) are destroyed.

I believe that after the example in this article, you should have some knowledge about unset (). At the very least, I use unset () to release the memory when the variable does not work.