在perl类中未定义DESTROY方法是否存在内存泄漏的风险？

如何解决在perl类中未定义DESTROY方法是否存在内存泄漏的风险？

根据上一个问题?（SO-63595446），我仍在使用Perl 5.8 Foo::Bar软件包。

TL; DR如果我没有在Perl 5.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方法将其显式重置为undef的情况下，您是否看到与ATTR使用相关的任何内存泄漏风险？

解决方法

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

Class :: Std实际上将一个析构函数添加到您的包中。没有它，%aaa和%ccc的内容将仅在程序退出时释放。 （如果没有新的对象在与旧对象相同的地址处发现，那么即使没有析构函数，您甚至可能会得到一个带有错误数据的对象。）

剩下$bbb。 Class :: 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;
}