What happens when unset releases memory in php?

First of all, will unset in PHP release memory?

First let us look at an example:

var_dump(memory_get_usage());
$a = "laruence";
var_dump(memory_get_usage());
unset($a);
var_dump(memory_get_usage());

Output (in different On a personal computer, it may vary depending on the system, PHP version, and loaded extensions):

int(90440)
int(90640)
int(90472

Note 90472-90440=32, so there are various To this conclusion, some people say that PHP's unset does not really free memory, and some say that PHP's unset only truly frees memory when it releases large variables (a large number of strings, large arrays) , Some people even say that it is meaningless to discuss memory at the PHP level.

So, will unset release the memory? Where did these 32 bytes go?
To answer this question, I We will start from two aspects:
Where did these 32 bytes go?
First of all we have to break a thought: PHP is not like C language, only you explicitly call the memory allocation related API Only then will there be memory allocation.
That is to say, in PHP, there are many memory allocation processes that we cannot see.
For example, for:

$a = "laruence";

The implicit memory allocation point is :
1. Allocate memory for the variable name and store it in the symbol table
2. Allocate memory for the variable value
So, you can’t just look at the appearance.
Second , Don’t doubt that PHP’s unset will indeed release memory (of course, it must be combined with reference and counting. For this part, please refer to my previous article to understand the PHP principle of variable separation/reference in depth), but this release is not C Release in the programming sense is not handed back to the OS.
For PHP, it provides a set of memory management APIs similar to the C language for memory allocation. These APIs correspond to the API meanings of C. Within PHP Memory is managed through these APIs.

When we call emalloc to apply for memory, PHP does not simply ask the OS for memory, but asks the OS for a large piece of memory, and then puts it into A piece of memory is allocated to the applicant, so that when there is logic to apply for memory, there is no need to apply for memory from the OS, avoiding frequent system calls.
For example, the following example:

Output: 
int(262144)
int(262144)
int(262144
That is, when we define the variable$a, PHP did not apply for new memory from the system.
 
Similarly, when we call efree to release memory, PHP will not return the memory to the OS, but will put this memory into the free memory list maintained by itself. For small pieces of memory, it is more The possibility is to put it in the memory cache list (postscript, some versions of PHP, such as PHP5.2.4, 5.2.6, 5.2.8 that I have verified, will not decrease when calling get_memory_usage() Go to the available memory block size in the memory cache list, causing it to appear that the memory remains unchanged after unset).
Now let me answer where these 32 bytes went, just like what I just said, Many memory allocation processes are not explicit. You will understand after reading the following code:
Output: 
string(43) "I am php.cn"
int(90808) //赋值前
int(90976)
int(90808) //是的, 内存正常释放
90808- 90808 = 0, normal, that is to say, these 32 bytes are occupied by the output function (strictly speaking, they are occupied by the output Header)
An array that only increases but does not decrease
 Hashtable is the core structure of PHP (to understand Hashtable, you can refer to my previous article for an in-depth understanding of PHP arrays (traversal order)). Arrays are also represented by it, and the symbol table is also an associative array. For the following code :

Copy code The code is as follows:
    var_dump("I am www.php.cn");
    var_dump(memory_get_usage());
    $array = array_fill(1, 100, "laruence");
    foreach ($array as $key => $value) {
        ${$value . $key} = NULL;
    }
    var_dump(memory_get_usage());
    foreach ($array as $key=> $value) {
        unset(${$value . $key});
    }
    var_dump(memory_get_usage());
We defined 100 variables, and then pressed Unset to see the output:
     string(43) "I am php.cn"
    int(93560)
    int(118848)
    int(104448
Wow, why is there so much less memory?
This is because for Hashtable, when defining it, it is impossible to allocate enough memory blocks at one time. To save an unknown number of elements, so PHP will only allocate a small part of the memory block to the HashTable during initialization, and then RESIZE the expansion when it is not enough. 
And the Hashtable can only be expanded, not To reduce, for the above example, when we stored 100 variables, the symbol table was not enough, so we did an expansion. When we unset the 100 variables in turn, the memory occupied by the variables was released (118848 – 104448), but the symbol table has not shrunk, so the small memory is occupied by the symbol table itself...
Now, do you have a preliminary understanding of PHP's memory management? Woolen cloth?
The above is the detailed content of What happens when unset releases memory in php?. For more information, please follow other related articles on the PHP Chinese website!