时间戳

首页 > 解决方案 > 在 perl 类中没有定义 DESTROY 方法是否存在内存泄漏的风险？

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

问题描述

Foo::Bar根据上一个问题（SO-63595446），我仍在研究 Perl 5.8包。

TL;DR 如果我没有在 Perl 5.8 Class:Std 包中定义DESTROY将属性重置为的方法，是否存在内存泄漏风险？undef

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

代码的简化版本：

#!/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），我可以定义一个自定义析构函数（例如将我的%aaaback 设置为undef），但我不知道它是否需要。

如果没有在 DESTROY 方法中将它们显式重置为 undef，您是否看到与 ATTR 使用相关的任何内存泄漏风险？

标签： perl

解决方案

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

Class::Std 实际上为您的包添加了一个析构函数。没有它，%aaaand的内容%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;
}

推荐阅读