Shulou(Shulou.com)06/03 Report--

This article mainly explains "PHP garbage collection mechanism related knowledge points collation", interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Next let the editor to take you to learn "PHP garbage collection mechanism-related knowledge points collation" bar!

PHP's current development framework, in addition to the mainstream commonly used FPM framework, must be based on the swoole extension of resident memory development.

In our FPM development mode, after each script ends, all variables are destroyed and memory is freed, so we don't have to worry too much.

But the resident memory development mode is different, if you do not pay attention to the use of variable memory, memory problems can not be well managed, resulting in memory leaks.

Therefore, we must be familiar with the garbage collection mechanism of PHP (Garbage Collector referred to as GC).

Copy on write and reference count copy on write

In the PHP7+ version, there is a feature about the operation of variable memory, which uses write-time copy, that is, a deep copy is made only when necessary (that is, a deep copy occurs when a write occurs).

When the variable value is interned string string type (variable name, function name, static string, class name, etc.), the variable value is stored in the static area, memory collection is taken over by the system globally, and the reference count will always be 1.

When the value of the assigned variable is integer or floating point, the bottom layer of php7 will store the value directly (the structure of php7 will directly store simple data types), and the refcount will be 0. Let's take a look at it in code:

$a = 'chris'.time (); $b = $a; / / at this time $b points to the same memory address of $a $c = $a; / / the same xdebug_debug_zval (' a'); / / a: (refcount=3, is_ref=0) string 'chris1614780053' (length=15) We observe the information of variables through Xdebug, they all refer to the same memory address, is a reference. $a = 'chris'.time (); $b =' Qingxuan'; $c = $a * debug debugging * * ('a'); xdebug_debug_zval ('b') / a: (refcount=2, is_ref=0) string 'chris1614780283' (length=15) / / b: (interned, is_ref=0) string' Qingxuan'(length=6) / / there is a static area where we observe the information of the variable through Xdebug, and then the value of $b has changed. At this time, the new memory space will be used, and the number of references to $an is-1. Reference count

Each php variable exists in a variable container called "zval". An zval variable container contains two bytes of additional information in addition to the type and value of the variable. The first is "is_ref", which is a Bool value that identifies whether the variable belongs to the reference collection (reference set). With this byte, the php engine can distinguish between normal variables and reference variables, and because php allows users to use custom references by using &, there is an internal reference counting mechanism in the zval variable container to optimize memory usage. The second extra byte is "refcount", which is used to indicate the number of variables (also known as symbols, or symbol) pointing to this zval variable container.

Description of the official document

To put it simply, it is to calculate the number of references to the variable. When the count refcount is not equal to 0, it means that the variable has been referenced and cannot be recycled directly, otherwise it can be recycled directly. Use the code to see

$a='chris'.time (); $baked memorabilitiescantilever; $baked 'Qingxuan'; unset ($c); xdebug_debug_zval ('a'); / a: (refcount=1, is_ref=0) string 'chris1614780526' (length=5) / / We can see that deleting $c does not delete $a because of the refcount=1 memory leak function a () {class A {public $ref; public $name; public function _ construct ($name) {$this- > name = $name; echo ($this- > name.'- > _ construct () '.PHP_EOL);} public function _ destruct () {echo ($this- > name.'- > _ destruct ();' .PHP_EOL);}} $A1 = new A ('$a1'); $a2 = new A ('$a2'); $a3 = new A ('$3'); $A1-> ref = $a2boot unset ($A1); unset ($a2); echo ('exit (1);'. PHP_EOL);} a (); echo ('exit (2)) '. PHP_EOL)

When the properties of $A1 and $a2 refer to each other, unset ($A1 djima2) can only delete the reference to the variable, but not the variable of the class. Why?

First of all, the instantiation variable of the class is divided into two steps

1: open up a class storage space for storing class data

2: instantiate a variable of type class, and the value points to the class storage space

When the variable is assigned successfully, the reference count of the class is 1. At the same time, A1-> ref points to a2, which increases the reference count of class a2 by 1. At the same time, class A1 is referenced by a2-> ref, and the reference count of A1 is increased by 1.

When unset, only the variable reference of the class, that is,-1, is deleted, but there is actually one reference to the class (cross-reference of the class).

This will cause the memory of these two classes to never be released until it is recycled by the gc mechanism loop lookup, or the script terminates the recycling (the domain cannot be recycled at the end of the domain).

Life cycle and variable recovery of PHP scope

Each method / function acts as a scope, and when the scope is run, all variables in the scope will be recycled, and global variables will not be recycled until the end of the script.

We can recycle manually in the following ways:

Unset (): the recycling principle of unset is actually reference count-1. When reference count-1 is followed by 0, the variable will be recycled directly, otherwise no action will be done (this is the reason for the memory leak above, reference count-1 is not equal to 0).

Assigned to null: = null and unset ($a), the effect is actually consistent. Null assigns the variable value to null, the original variable value reference count-1, while unset cleans the variable name from the php underlying variable table and counts the variable value reference count-1. The only difference is that, = null, the variable name still exists, and after unset, the variable is gone.

Variable override recycling: reclaim by assigning other values (such as null) to the variable, but in terms of program memory usage, overwriting the variable is not memory recycling in the sense, but changing the variable's memory to other values. The memory is not emptied directly.

Gc_collect_cycles: forces periodic collection, which is performed in PHP execution once the root buffer is full or when the gc_collect_cycles () function is called

In addition: in order to avoid having to check all the garbage cycles in which the reference count may be reduced, PHP will have an algorithm to put suspected garbage variables in the root buffer (root buffer), and will also reclaim the garbage buffer when the root buffer is full.

At this point, I believe you have a deeper understanding of the "PHP garbage collection mechanism-related knowledge points", might as well come to the actual operation of it! Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.