Interpretation of the garbage collection mechanism in PHP_php skills

Basic GC concepts of PHP
PHP language, like other languages, has a garbage collection mechanism. So what we want to explain to you today is related to the PHP garbage collection mechanism. Hope it helps everyone. PHP strtotime application experience PHP memory_get_usage() manages memory Detailed explanation of PHP unset global variable usage problems PHP unset() function destroys variables to teach you how to quickly implement PHP full site permission verification 1. PHP garbage collection mechanism (Garbage Collector, referred to as GC) in PHP , when no variables point to this object, this object becomes garbage. PHP will destroy it in memory; this is PHP's GC garbage disposal mechanism to prevent memory overflow. When a PHP thread ends, all memory space currently occupied will be destroyed, and all objects in the current program will be destroyed at the same time. The GC process generally starts running with each SESSION. The purpose of gc is to automatically destroy and delete the session files after they expire. 2. __destruct /unset __destruct() The destructor is executed when the garbage object is recycled.
Unset destroys the variable pointing to the object, not the object. 3. Session and PHP garbage collection mechanism Due to the working mechanism of PHP, it does not have a daemon thread to regularly scan Session information and determine whether it is invalid. When a valid request occurs, PHP will use the global variables session.gc_probability and session The value of .gc_divisor determines whether to enable a GC. By default, session.gc_probability=1, session.gc_divisor =100 means there is a 1% possibility of starting a GC (that is, there is only one gc in 100 requests) Will be started with one of the 100 requests). The job of the PHP garbage collection mechanism is to scan all Session information, subtract the last modification time of the session from the current time, and compare it with the session.gc_maxlifetime parameter. If the survival time exceeds gc_maxlifetime (default 24 minutes), the session will be deleted.
However, if your web server has multiple sites, unexpected results may occur when GC processes sessions. The reason is: when GC is working, it does not distinguish between sessions of different sites. So how to solve this problem? ?
1. Modify session.save_path, or use session_save_path() to save the session of each site to a dedicated directory,
2. Provide the startup rate of GC. Naturally, as the startup rate of PHP garbage collection mechanism increases, the performance of the system will decrease accordingly, which is not recommended.
3. Determine the survival time of the current session in the code and delete it using session_destroy().

Basic knowledge of reference counting
Each PHP variable exists in a variable container called "zval". A zval variable container, in addition to the type and value of the variable, also includes two bytes of additional information. The first one is "is_ref", which is The bool value is used to identify whether this variable belongs to a reference set. Through this byte, the PHP engine can distinguish ordinary variables from reference variables. Since PHP allows users to use custom references by using &, the zval variable There is also an internal reference counting mechanism in the container to optimize memory usage. The second extra byte is "refcount", which is used to represent the number of variables (also called symbols) pointing to this zval variable container.

When a variable is assigned a constant value, a zval variable container will be generated, as shown in the following example:

  <&#63;php 
  $a = "new string"; 
   
  &#63;> 

In the above example, the new variable is a, which is generated in the current scope. And a variable container with type string and value "new string" is generated. In the additional two bytes of information, "is_ref" It is set to false by default because no custom reference is generated. "refcount" is set to 1 because there is only one variable using this variable container. Call xdebug to view the variable content:

  <&#63;php 
  $a = "new string"; 
   
  xdebug_debug_zval('a'); 
  &#63;> 

The above code will output:

  a: (refcount=1, is_ref=0)='new string' 

Add a reference count to variable a

  <&#63;php 
  $a = "new string"; 
   
  $b = $a; 
  xdebug_debug_zval('a'); 
  &#63;> 

The above code will output:

  a: (refcount=2, is_ref=0)='new string' 

At this time, the reference count is 2, because the same variable container is associated with variable a and variable b. PHP will not copy the generated variable container when it is not necessary. The variable container is destroyed when "refcount" becomes 0. When any variable associated with a certain variable leaves its scope (for example: the function execution ends), or the unset() function is called on the variable, the "refcount" will be reduced by 1, as the following example illustrates:

  <&#63;php 
  $a = "new string"; 
  $b = $c = $a; 
  xdebug_debug_zval('a'); 
  unset($b, $c); 
  xdebug_debug_zval('a'); 
  &#63;> 

The above code will output:

  a: (refcount=3, is_ref=0)='new string' a: (refcount=1, is_ref=0)='new string' 

If we execute unset($a) now, the container containing the type and value $ will be deleted from memory

Compound types

Things get a little more complicated when considering composite types like array and object. Unlike values ​​of scalar type, variables of array and object types store their members or properties in their own symbol tables. This means that the following example will generate three zval variable containers

  <&#63;php 
  $a = array('meaning' => 'life', 'number' => 42); 
   
  xdebug_debug_zval('a'); 
  &#63;> 

The above code output:

  a: (refcount=1, is_ref=0)=array ('meaning' => (refcount=1, is_ref=0)='life', 'number' => (refcount=1, is_ref=0)=42) 

这三个zval变量容器是:a,meaning,number.增加和减少refcount的规则和上面提到的一样

特例,添加数组本身作为数组元素时:

  <&#63;php 
  $a = array('one'); 
   
  $a[] = &$a; 
   
  xdebug_debug_zval('a'); 
  &#63;> 

以上代码输出的结果:

  a: (refcount=2, is_ref=1)=array (0 => (refcount=1, is_ref=0)='one', 1 => (refcount=2, is_ref=1)=...) 

可以看到数组a和数组本身元素a[1]指向的变量容器refcount为2

当对数组$a调用unset函数时,$a的refcount变为1,发生了内存泄漏

清理变量容器的问题
尽管不再有某个作用域中的任何符号指向这个结构(就是变量容器),由于数组元素"1"仍然指向数组本身,所以这个容器不能被消除.因为没有另外的符号指向它,用户没有办法清除这个结构,结果就会导致内存泄漏.庆幸的是,php将在请求结束时清除这个数据结构,但是php清除前,将耗费不少内存空间

回收周期
5.3.0PHP使用了新的同步周期回收算法,来处理上面所说的内存泄漏问题

首先,我们先要建立一些基本规则:
如果一个引用计数增加,它将继续被使用,当然就不再垃圾中.如果引用技术减少到零,所在的变量容器将被清除(free).就是说,仅仅在引用计数减少到非零值时,才会产生垃圾周期(grabage cycle).其次,在一个垃圾周期中,通过检查引用计数是否减1,并且检查哪些变量容器的引用次数是零,来发现哪部分是垃圾

为避免不得不检查所有引用计数可能减少的垃圾周期,这个算法把所有可能根(possible roots 都是zval变量容器),放在根缓冲区(root buffer)中(用紫色标记),这样可以同时确保每个可能的垃圾根(possible garbage root)在缓冲区只出现一次.仅仅在根缓冲区满了时,才对缓冲区内部所有不同的变量容器执行垃圾回收操作。