如果不在perl类中定义DESTROY方法，是否存在内存泄漏的风险

Question

根据前面的问题(SO-63595446)，我仍在开发Perl 5.8Foo::Bar包。

TL；DR如果我不在Perl5.8 Class:Std包中定义DESTROY方法将属性重置为undef，是否存在内存泄漏风险

---

我一直在尝试记忆一些实例属性：

• 最初我是像BarObj$bbb那样做的，但在测试中，我立即看到了一个竞争条件：我使用了一个类变量而不是实例变量，结果在多个实例之间共享
• 我实现为BarObj%aaa，现在看起来很好

代码的简化版本：

#!/usr/bin/env perl
use 5.8.0;
use strict;
use warnings;
use Data::Dumper qw(Dumper);
use Scalar::Util qw(refaddr);
{
package FooObj;
use strict;
use warnings;
use Class::Std;
my %ccc :ATTR;
sub BUILD {
my ($self, $ident, $args) = @_;
$ccc{$ident} = $$args{foobar};
}
sub retrieve {
my $args = shift;
my $foobar = $$args{foobar};
FooObj->new({foobar => $foobar});
}
}
{
package BarObj;
FooObj->import;
use strict;
use warnings;
use Class::Std;
use Scalar::Util qw(refaddr);
my %aaa :ATTR( :get<aaa> );
my $bbb = {};
sub doSomething {
my ($self, $args) = @_;
my $foo = $$args{foo};
my $bar = $$args{bar};
my $cacheKey = "$$args{foo}:$$args{bar}";
# using ident $self
my $aaaCache = $aaa{ident $self}->{$cacheKey};
# not using ident $self
my $bbbCache = $$bbb{$cacheKey};
return if $aaaCache && $bbbCache;
my $f = FooObj::retrieve({foobar => $cacheKey});
$aaa{ident $self}->{$cacheKey} = refaddr($f) unless $aaaCache;
$$bbb{$cacheKey} = refaddr($f) unless $bbbCache;
}
sub get_bbb {
return $bbb;
}
}
my $bar1 = BarObj->new();
my $bar2 = BarObj->new();
my $input1 = { foo => 'aaa', bar => 'aaa' };
my $input2 = { foo => 'bbb', bar => 'bbb' };
print '$bar1 refaddr: ' . refaddr($bar1) .
' $bar2 refaddr: ' . refaddr($bar2) . "n";
$bar1->doSomething($input1);
$bar1->doSomething($input2);
$bar2->doSomething($input1);
$bar2->doSomething($input2);
print '$bar1 %aaa: ' . Dumper($bar1->get_aaa());
print '$bar2 %aaa: ' . Dumper($bar2->get_aaa());
print '$bar1 %bbb: ' . Dumper($bar1->get_bbb());
print '$bar2 %bbb: ' . Dumper($bar2->get_bbb());

摘录的输出：

$bar1 refaddr: 140467484583408 $bar2 refaddr: 140467484303424
$bar1 %aaa: $VAR1 = {
'aaa:aaa' => '140467484303784',
'bbb:bbb' => '140467467923232'
};
$bar2 %aaa: $VAR1 = {
'bbb:bbb' => '140467467923520',
'aaa:aaa' => '140467467923424'
};
$bar1 %bbb: $VAR1 = {
'bbb:bbb' => '140467467923232',
'aaa:aaa' => '140467484303784'
};
$bar2 %bbb: $VAR1 = {
'bbb:bbb' => '140467467923232',
'aaa:aaa' => '140467484303784'
};

我想知道垃圾收集器是如何处理我的包的，以及我存储的引用是如何被销毁的。根据医生的说法(https://perldoc.perl.org/perlobj.html#Destructors)我可以定义一个自定义析构函数(例如，将%aaa设置回undef)，但我不知道是否需要它。

在DESTROY方法中，如果没有明确地将ATTR重置为undef，您是否看到与ATTR使用相关的内存泄漏风险？

Answer 1

什么清空%aaa、$bbb和%ccc？

Class:：Std实际上为您的包添加了一个析构函数。如果没有它，%aaa和%ccc的内容只有在程序退出时才会被释放。(如果没有析构函数，如果在与旧对象相同的地址上发现一个新对象，你甚至可能得到一个数据不正确的对象。)

剩下$bbb。类：：Std对此一无所知，而且您还没有采取措施清空它，所以在程序退出之前，它的内容不会被清空。

use Class::Std;
use Data::Dumper qw( Dumper );
my %foo :ATTR;   # Akin to %aaa and %ccc
my %bar;         # Akin to %$bbb
sub _dump {
local $Data::Dumper::Indent = 0;
local $Data::Dumper::Terse  = 1;
print("%foo: " . Dumper(%foo) . "n");
print("%bar: " . Dumper(%bar) . "n");
}
sub do_something {
my $self = shift;
my %args = @_;
$foo{ident $self} = $args{foo};
$bar{ident $self} = $args{bar};
}
{
my $obj = __PACKAGE__->new();
$obj->do_something( foo => 123, bar => 456 );
print("BEFORE DESTROY:n");
_dump();
}
print("n");
print("After DESTROY:n");
_dump();

Before DESTROY:
%foo: {'140737100652856' => 123}
%bar: {'140737100652856' => 456}
After DESTROY:
%foo: {}
%bar: {'140737100652856' => 456}

你需要像这样的东西

{
my $old_destroy = &DESTROY;
my $new_destroy = sub {
... empty the appropriate entry of $bbb ...
$old_destroy->(@_);
};
no warnings qw( redefine );
*DESTROY = $new_destroy;
}