An in-depth analysis of PHP memory management: Who touched my memory_PHP tutorial

First let us look at a problem: The output of the following code,

Copy the code The code is as follows:

var_dump(memory_get_usage ());
$a = "laruence";
var_dump(memory_get_usage());
unset($a);
var_dump(memory_get_usage());
output(in my On your personal computer, it may vary due to different systems, PHP versions, and loaded extensions):
int(90440)
int(90640)
int(90472)

Notice that 90472-90440=32, so there are various conclusions. Some people say that PHP’s unset does not really release memory, and some say that PHP’s unset only releases large variables (a large number of strings, large Array), some people even say that it is meaningless to discuss memory at the PHP level.
So, will unset release memory?
These 32 words Where did the section go?
To answer this question, I will start from two aspects:
Where did these 32 bytes go?
First we have to break a thinking: PHP Unlike the C language, memory allocation will occur only when you explicitly call the memory allocation related API.
That is to say, in PHP, there are many memory allocation processes that we cannot see.
For example:
$a = "laruence";
The implicit memory allocation points are:
1.1. Allocate memory for the variable name and store it in Symbol table
2.2. Allocate memory for variable values
So, you can’t just look at the appearance.
Second, don’t doubt that PHP’s unset will indeed release memory, but this release is not in the sense of C programming The release is not handed back to the OS.
For PHP, it provides a set of memory management API similar to the C language for memory allocation:

Copy code The code is as follows:

emalloc(size_t size);
efree(void *ptr);
ecalloc(size_t nmemb, size_t size);
erealloc( void *ptr, size_t size);
estrdup(const char *s);
estrndup(const char *s, unsigned int length);

The API meaning of these APIs and C Correspondingly, memory is managed internally in PHP 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 Allocate one of the blocks 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:

Copy code The code is as follows:

var_dump(memory_get_usage(TRUE)); // Note that what is obtained is real_size
$a = "laruence";
var_dump(memory_get_usage(TRUE));
unset($a);
var_dump(memory_get_usage(TRUE));
output :
int(262144)
int(262144)
int(262144)

That is, when we define the variable $a, PHP does 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 add this memory to the free memory list it maintains. For small pieces of memory, More likely, 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 when calling get_memory_usage() Subtracting the available memory block size in the memory cache list, it seems 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:

Copy the code The code is as follows:

var_dump("I am Laruence, From http://www.laruence.com");
var_dump(memory_get_usage());
$a = "laruence";
var_dump(memory_get_usage());
unset($a);
var_dump(memory_get_usage());
Output:
string(43) "I am Laruence, From http:// /www.laruence.com"
int(90808) //Before assignment
int(90976)
int(90808) //Yes, the memory is released normally
90808-90808 = 0, It's 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. 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 Laruence, From http://www.laruence.com");
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 clicked Unset to see the output:

Copy the code The code is as follows:

string(43) "I am Laruence, From http://www.laruence.com"
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 unknown number of elements, so PHP will only allocate a small part of the memory block to the HashTable during initialization. When it is not enough, it will RESIZE to expand the capacity,

and the Hashtable can only be expanded, not reduced. For In the above example, when we stored 100 variables, the symbol table was not enough and we made 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 amount of memory is taken up by the symbol table itself...

Now, do you have a preliminary understanding of PHP's memory management?

http://www.bkjia.com/PHPjc/327674.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/327674.htmlTechArticleFirst let us look at a problem: the output of the following code, copy the code as follows: var_dump(memory_get_usage()); $a = "laruence"; var_dump(memory_get_usage()); unset($a); var_dump(m...