Memory management of PHP variables

This article mainly introduces the memory management of PHP variables, which has certain reference value. Now I share it with everyone. Friends in need can refer to it

Every computer language needs some containers to save variables data. In some languages, variables have specific types, such as strings, arrays, objects, etc. For example, C and Pascal fall into this category. PHP has no such type. In PHP, a variable that is a string on one line may become a number on the next line. Variables can often be easily converted between different types, even automatically. A large part of the reason why PHP is a simple and powerful language is that it has weakly typed variables. But sometimes this can lead to some interesting problems.

Inside PHP, variables are stored in a container called zval. It contains not only the value of the variable, but also the type of the variable. Python, like PHP, also has a label to mark the variable type. The variable container contains some fields that the Zend engine uses to distinguish whether they are referenced or not. It also contains the reference count of this value.

Variables are stored in a symbol table equivalent to an associative array. This array is keyed by variable names and points to containers containing these variables. As shown in the figure below:

Reference counting

PHP tries to be smart when copying variables (such as $a = $b) some. "=" is also called the assignment operator. When performing an assignment operation, the Zend engine will not create a new variable window, but will increase the refcount field of the variable window. You can imagine that when this variable is a huge string or a huge array, this will How much memory is saved. As shown in the figure below:

Step 1: Variable a contains the text "this is". By default, the reference count is equal to 1

Step 2: Assign variable $a to $b and $c. There is no new variable container generated here, just refcount is increased by 1 each time a variable is assigned. Because two assignment operations are performed here, refcount will eventually become 3.

Now, maybe you are wondering what will happen when the variable $c changes. Depending on the value of refcount, it will be processed in two different ways. If refcount equals 1, the variable container will update its value (and perhaps its type as well). If refcount is greater than 1, a variable container containing the new value (and type) will be created. As shown in the third step in Figure 2, the refcount value of the variable container where the $a variable is located is subtracted by one. Now the refcount value is 2, and the refcount value of the newly created container is 1. When the unset function is used on a variable, the refcount value of the container where the variable is located will be reduced by one, as shown in step 4 of the figure. If the value of refcount is less than 1, the Zend Engine will translate the variable container, as shown in step 5 of the figure.

Passing Variables to Functions

In addition to the global symbol table shared by all scripts, each user-defined function will create its own symbol table when called. Used to store its own variables. When a function is called, the Zend engine will create such a symbol table, and the function table will be released when the function returns. A function either returns through a return statement or returns because the function ends (Translator's Note: Functions that do not return will return NULL by default). As shown below:

Figure 3 details how variables are passed to functions.

In the first step, we assign "thisis" to the variable $a, and then we pass this variable to the $s variable of the do_something() function.

In the second step, you can see that this is the same operation as variable assignment (similar to the $b = $a we mentioned in the previous section), except that it is stored in a different symbol table ( function symbol table), and the reference count is incremented by 2 instead of by 1. The reason is that the function stack also contains a reference to this variable container.

The third step, when we assign a new value to the variable $s, the refcount of the original variable container is reduced by 1, and a variable container containing the new value is created.

The fourth step is to return a variable through the return statement. The returned variable gets an entity from the global symbol table and increments its refcount by 1. When the function ends, the function's symbol table is destroyed. During the destruction process, the Zend engine will traverse each variable in the symbol table and reduce its refcount value. When the refount value of the variable container becomes 0, the variable container will be destroyed. As you can see, due to PHP's reference counting mechanism, the variable container is not copied from the function. If variable $s has not been modified in the third step, variables $a and $b will always point to the same variable container (the refcount of this container is 2). In this case, the statement $a = "this is" will not create a copy of the variable container.

Related recommendations:

php variable copy-on-write mechanism

The above is the detailed content of Memory management of PHP variables. For more information, please follow other related articles on the PHP Chinese website!