在平常php-fpm的时候,大概很少人留意php的变量回收,但是到swoole常驻内存开发后,就不得不重视这个了,由于在常驻内存下,假如不理解变量回收机制,大概就会显现内存泄露的问题,本文将一步步带你理解php的垃圾回收机制,让你写出的代码不再内存走漏

写时复制

第一,php的变量复制用的是写时复制方式,举个例子.

$a='仙士可'.time();
$b=$a;
$c=$a;
//这个时候内存占用雷同,$b,$c都将指向$a的内存,无需额外占用
 
$b='仙士可1号';
//这个时候$b的数据已经改动了,没法再援用$a的内存,所以需要额外给$b开辟内存空间
 
$a='仙士可2号';
//$a的数据发生了转变,一样的,$c也没法援用$a了,需要给$a额外开辟内存空间

具体写时复制可查看:php写时复制

援用计数

既然变量会援用内存,那么删除变量的时候,就会显现一个问题了:

$a='仙士可';
$b=$a;
$c=$a;
//这个时候内存占用雷同,$b,$c都将指向$a的内存,无需额外占用
 
$b='仙士可1号';
//这个时候$b的数据已经改动了,没法再援用$a的内存,所以需要额外给$b开辟内存空间
 
unset($c);
//这个时候,删除$c,由于$c的数据是援用$a的数据,那么直接删除$a?

很明显,当$c援用$a的时候,删除$c,不克不及把$a的数据直接给删除,那么该如何做呢?

这个时候,php底层就使用到了援用计数这个概念

援用计数,给变量援用的次数停止运算,当计数不等于0时,说明这个变量已经被援用,不克不及直接被回收,不然可以直接回收,例如:

$a = '仙士可'.time();
$b = $a;
$c = $a;
 
xdebug_debug_zval('a');
xdebug_debug_zval('b');
xdebug_debug_zval('c');
 
$b='仙士可2号';
xdebug_debug_zval('a');
xdebug_debug_zval('b');
 
echo "足本完毕\n";

将输出:

a: (refcount=3, is_ref=0)='仙士可1578154814'
b: (refcount=3, is_ref=0)='仙士可1578154814'
c: (refcount=3, is_ref=0)='仙士可1578154814'
a: (refcount=2, is_ref=0)='仙士可1578154814'
b: (refcount=1, is_ref=0)='仙士可2号'
足本完毕

留意,xdebug_debug_zval函数是xdebug扩展的,使用前必需安置xdebug扩展

援用计数非凡状况

当变量值为整型,浮点型时,在赋值变量时,php7底层将会直接把值储备(php7的构造体将会直接储备简便数据类型),refcount将为0

$a = 1111;
$b = $a;
$c = 22.222;
$d = $c;
 
xdebug_debug_zval('a');
xdebug_debug_zval('b');
xdebug_debug_zval('c');
xdebug_debug_zval('d');
echo "足本完毕\n";

输出:

a: (refcount=0, is_ref=0)=1111
b: (refcount=0, is_ref=0)=1111
c: (refcount=0, is_ref=0)=22.222
d: (refcount=0, is_ref=0)=22.222
足本完毕

当变量值为interned string字符串型(变量名,函数名,静态字符串,类名等)时,变量值储备在静态区,内存回收被系统全局接管,援用计数将不断为1(php7.3)

$str = '仙士可';    // 静态字符串

$str = '仙士可' . time();//一般字符串

$a = 'aa';
$b = $a;
$c = $b;
 
$d = 'aa'.time();
$e = $d;
$f = $d;
 
xdebug_debug_zval('a');
xdebug_debug_zval('d');
echo "足本完毕\n";

输出:

a: (refcount=1, is_ref=0)='aa'
d: (refcount=3, is_ref=0)='aa1578156506'
足本完毕

当变量值为以上几种时,复制变量将会直接拷贝变量值,所以将不存在屡次援用的状况

援用时援用计数转变

如下代码:

$a = 'aa';
$b = &$a;
$c = $b;
 
xdebug_debug_zval('a');
xdebug_debug_zval('b');
xdebug_debug_zval('c');
echo "足本完毕\n";

将输出:

a: (refcount=2, is_ref=1)='aa'
b: (refcount=2, is_ref=1)='aa'
c: (refcount=1, is_ref=0)='aa'
足本完毕

当援用时,被援用变量的value乃至类型将会更换为援用类型,并将援用值指向本来的值内存地址中.

之后援用变量的类型也会更换为援用类型,并将值指向本来的值内存地址,这个时候,值内存地址被援用了2次,所以refcount=2.

而$c并非是援用变量,所以将值复制给了$c,$c援用还是为1

具体援用计数知识,底层道理可查看:https://www.cnblogs.com/sohuhome/p/9800977.html

php生命周期

php将每个运转域作为一次生命周期,每次施行完一个域,将回收域内所有相关变量:

<?php
/**
 * Created by PhpStorm.
 * User: Tioncico
 * Date: 2020/1/6 0006
 * Time: 14:22
 */
 
echo "php文件的全局开端\n";
 
class A{
    protected $a;
    function __construct($a)
    {
        $this->a = $a;
        echo "类A{$this->a}生命周期开端\n";
    }
    function test(){
        echo "类test办法域开端\n";
        echo "类test办法域完毕\n";
    }
//通过类析构函数的特性,当类初始化或回收时,会调取响应的办法
    function __destruct()
    {
        echo "类A{$this->a}生命周期完毕\n";
        // TODO: Implement __destruct() method.
    }
}
 
function a1(){
    echo "a1函数域开端\n";
    $a = new A(1);
    echo "a1函数域完毕\n";
    //函数完毕,将回收所有在函数a1的变量$a
}
a1();
 
$a = new A(2);
 
echo "php文件的全局完毕\n";
//全局完毕后,会回收全局的变量$a

可看出,每个办法/函数都作为一个作用域,当运转完该作用域时,将会回收这里面的所有变量.

再看看这个例子:

echo "php文件的全局开端\n";
 
class A
{
    protected $a;
 
    function __construct($a)
    {
        $this->a = $a;
        echo "类{$this->a}生命周期开端\n";
    }
 
    function test()
    {
        echo "类test办法域开端\n";
        echo "类test办法域完毕\n";
    }
 
//通过类析构函数的特性,当类初始化或回收时,会调取响应的办法
    function __destruct()
    {
        echo "类{$this->a}生命周期完毕\n";
        // TODO: Implement __destruct() method.
    }
}
 
$arr = [];
$i = 0;
while (1) {
    $arr[] = new A('arr_' . $i);
    $obj = new A('obj_' . $i);
    $i++;
    echo "数组大小:". count($arr).'\n';
    sleep(1);
//$arr 会随着轮回,渐渐的变大,直到内存溢出
 
}
 
echo "php文件的全局完毕\n";
//全局完毕后,会回收全局的变量$a

全局变量只要在足本完毕后才会回收,而在这份代码中,足本永久不会被完毕,也就说明变量永久不会回收,$arr还在不竭的增添变量,直到内存溢出.

内存走漏

请看代码:

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 = $a2;
    $a2->ref = $a1;
 
    unset($a1);
    unset($a2);
 
    echo('exit(1);'.PHP_EOL);
}
a();
echo('exit(2);'.PHP_EOL);

当$a1和$a2的属性互相援用时,unset($a1,$a2) 只能删除变量的援用,却没有真正的删除类的变量,这是为什么呢?

第一,类的实例化变量分为2个步骤,1:开拓类储备空间,用于储备类数据,2:实例化一个变量,类型为class,值指向类储备空间.

当给变量赋值成功后,类的援用计数为1,同时,a1->ref指向了a2,致使a2类援用计数增添1,同时a1类被a2->ref援用,a1援用计数增添1

当unset时,只会删除类的变量援用,也就是-1,但是该类其实还存在了一次援用(类的互相援用),

这将造成这2个类内存永久没法开释,直到被gc机制轮回查寻回收,或足本终止回收(域完毕没法回收).

手动回收机制

在上面,我们知道了足本回收,域完毕回收2种php回收方式,那么可以手动回收吗?答案是可以的.

手动回收有以下几种方式:

unset,赋值为null,变量赋值覆盖,gc_collect_cycles函数回收

unset

unset为最常用的一种回收方式,例如:

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);
    }
}
 
$a = new A('$a');
$b = new A('$b');
unset($a);
//a将会先回收
echo('exit(1);' . PHP_EOL);
//b需要足本完毕才会回收

输出:

$a->__construct();
$b->__construct();
$a->__destruct();
exit(1);
$b->__destruct();

unset的回收道理其实就是援用计数-1,当援用计数-1之后为0时,将会直接回收该变量,不然不做操纵(这就是上面内存走漏的缘由,援用计数-1并没有等于0)

=null回收

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);
    }
}
 
$a = new A('$a');
$b = new A('$b');
$c = new A('$c');
unset($a);
$c=null;
xdebug_debug_zval('a');
xdebug_debug_zval('b');
xdebug_debug_zval('c');
 
echo('exit(1);' . PHP_EOL);

=null和unset($a),作用其实都为一致,null将变量值赋值为null,本来的变量值援用计数-1,而unset是将变量名从php底层变量表中清算,并将变量值援用计数-1,独一的不同在于,=null,变量名还存在,而unset之后,该变量就没了:

$a->__construct();
$b->__construct();
$c->__construct();
$a->__destruct();
$c->__destruct();
a: no such symbol //$a已经不在符号表
b: (refcount=1, is_ref=0)=class A { public $ref = (refcount=0, is_ref=0)=NULL; public $name = (refcount=1, is_ref=0)='$b' }
c: (refcount=0, is_ref=0)=NULL  //c还存在,只是值为null
exit(1);
$b->__destruct();

变量覆盖回收

通过给变量赋值其他值(例如null)停止回收:

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);
    }
}
 
$a = new A('$a');
$b = new A('$b');
$c = new A('$c');
$a=null;
$c= '练习时长两年半的个人练习生';
xdebug_debug_zval('a');
xdebug_debug_zval('b');
xdebug_debug_zval('c');
 
echo('exit(1);' . PHP_EOL);

将输出:

$a->__construct();
$b->__construct();
$c->__construct();
$a->__destruct();
$c->__destruct();
a: (refcount=0, is_ref=0)=NULL
b: (refcount=1, is_ref=0)=class A { public $ref = (refcount=0, is_ref=0)=NULL; public $name = (refcount=1, is_ref=0)='$b' }
c: (refcount=1, is_ref=0)='练习时长两年半的个人练习生'
exit(1);
$b->__destruct();

可以看出,c由于覆盖赋值,将本来A类实例的援用计数-1,致使了$c的回收,但是从程序的内存占用来说,覆盖变量并不是意义上的内存回收,只是将变量的内存修改为了其他值.内存不会直接清空.

gc_collect_cycles

回到此前的内存走漏章节,当写程序不当心造成了内存走漏,内存越来越大,可是php默许只能足本完毕后回收,那该如何办呢?我们可以使用gc_collect_cycles 函数,停止手动回收

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');
 
    $a1->ref = $a2;
    $a2->ref = $a1;
 
    $b = new A('$b');
    $b->ref = $a1;
 
    echo('$a1 = $a2 = $b = NULL;'.PHP_EOL);
    $a1 = $a2 = $b = NULL;
    echo('gc_collect_cycles();'.PHP_EOL);
    echo('// removed cycles: '.gc_collect_cycles().PHP_EOL);
    //这个时候,a1,a2已经被gc_collect_cycles手动回收了
    echo('exit(1);'.PHP_EOL);
 
}
a();
echo('exit(2);'.PHP_EOL);

输出:

$a1->__construct();
$a2->__construct();
$b->__construct();
$a1 = $a2 = $b = NULL;
$b->__destruct();
gc_collect_cycles();
$a1->__destruct();
$a2->__destruct();
// removed cycles: 4
exit(1);
exit(2);

留意,gc_colect_cycles 函数会从php的符号表,遍历所有变量,去实现援用计数的运算并清算内存,将耗损大量的cpu资源,不倡议频繁使用

别的,除去这些办法,php内存抵达必然临界值时,会主动调取内存清算(我猜的),每次调取都会耗损大量的资源,可通过gc_disable 函数,去关闭php的主动gc

引荐教程：《php教程》

以上就是商量php的垃圾回收机制的具体内容，更多请关注百分百源码网其它相关文章！