Perl面向对象(3)：解构——对象销毁

本系列：

* Perl面向对象(1)：从代码复用开始 <https://www.cnblogs.com/f-ck-need-u/p/9798757.html>

* Perl面向对象(2)：对象 <https://www.cnblogs.com/f-ck-need-u/p/9811119.html>

* Perl面向对象(3)：解构——对象销毁 <https://www.cnblogs.com/f-ck-need-u/p/9818016.html>
第3篇依赖于第2篇，第2篇依赖于1篇。


perl中使用引用计数的方式管理内存，对象也是引用，所以对象的销毁也是由引用计数的管理方式进行管理的。也就是说，当一个对象(也就是一个数据结构)引用数为0时，这个对象就会被Perl回收。


对象回收的俗称是"对象销毁"(destroy)，术语是解构(destruction)，在Perl中回收对象是通过一个名为DESTROY的特殊方法进行回收的，和构造器创建对象相反，这个方法解除构造，所以称之为解构器(destructor)。

关于DESTROY

当Perl中对象的最后一个引用要消失时，Perl将自动调用DESTROY方法。Perl处理DESTROY的方式和普通方法一样：

* 先从本类中搜索，搜索不到再搜索父类

* 传递的第一个参数为类名或对象名
和普通方法不同的是，DESTROY是在对象被销毁时自动调用的。

需要搞清楚的是，DESTROY这个特殊方法是当对象的引用数将要为0之前调用的，该方法执行完成后，对象相关的数据结构才被完全释放，引用数才真正变成0
。所以，在DESTROY方法中可以定义很多善后工作(比如清理临时数据)或用来调试，善后完成后才完全释放对象。

DESTROY示例

例如，在lib/Animal.pm中定义父类Animal：
#!/usr/bin/env perl use strict; use warnings; package Animal; sub new { my
$class = shift; my $name = shift; bless \$name,$class; } sub DESTROY { # 添加此方法
my $class = shift; print "OBJECT-> ",$class->name()," <-died\n" } sub name { my
$self = shift; ref $self ? $$self : "an unamed Class $self"; } sub speak { my
$class = shift; print $class->name()," goes ",$class->sound(),"!\n"; } sub
sound { die 'You have to define sound() in a subclass'; } 1;
Animal的子类Horse，文件lib/Horse.pm中：
#!/usr/bin/env perl use strict; use warnings; package Horse; use parent
qw(Animal); sub sound { "neigh" } 1;
然后在speak.pl程序文件中创建对象：
#!/usr/bin/env perl use strict; use warnings; use lib "lib"; use Horse; my
$bm_horse = Horse->new("baima"); # 创建引用 $bm_horse->speak(); #
此处程序结束，引用将全部消失，将自动调用DESTROY方法销毁对象
输出结果：
baima goes neigh! OBJECT-> baima <-died
为了更进一步测试DESTROY，将上面的对象创建放进代码块中：
use lib "lib"; use Horse; { my $bm_horse = Horse->new("baima"); # 创建引用
$bm_horse->speak(); } # 引用到此消失，自动调用DESTROY方法销毁对象 print "program end\n";
所以输出结果为：
baima goes neigh! OBJECT-> baima <-died program end
程序结束时会自动销毁所有对象，这时DESTROY()是在END语句块之后才调用的。

嵌套对象的销毁

perl的对象就是一个数据结构，如果这个对象的数据结构是数组、hash，那么可以进行对象的嵌套。


对象嵌套的场景很多，最简单的解释：创建了Animal类后，再创建一个农场类，农场类的数据结构使用数组、hash结构，这个农场类里会创建一个一个的Animal对象放进农村类的数据结构中。通过农场对象，可以获取这个对象中有哪些以及有多少Animal对象。

在销毁嵌套对象的时候，先调用外层的DESTROY方法，然后在DESTROY结束的时候销毁外层对象，最后销毁内层对象
。也就是说，先让Animal对象们无家可归。注意，销毁外层对象只是会减少一次内层对象的引用，如果一个对象同时添加到了两个或多个嵌套结构中，销毁一个嵌套结构，并不会销毁完全销毁这个对象。就像是一个文件两个硬链接，它们处于两个目录下，删除一个目录只是删除这个硬链接。

当然，这都是通过代码进行控制的。下面将会演示这两种不同的嵌套对象销毁方式。

先销毁外层，再销毁内层

例如，在lib/Farm.pm文件中创建一个农场，使用数组结构作为对象结构，为了方便看结果，将Farm放进代码块：
#!/usr/bin/env perl use strict; use warnings; { package Farm; sub new { bless
[],shift } sub add { push @{shift()},shift } # 注意，解除引用时shift()必须不能省略括号，否则会产生歧义
sub contents { @{shift()} } sub DESTROY { my $self = shift; print "$self is
being destroyed...\n"; for($self->contents()){ print " ",$_->name, " goes
homeless\n"; } print "$self destroyed...\n"; } # Farm的对象将在此被销毁 #
Farm中嵌套的所有对象将在此被一次性销毁(减少引用数) } 1;
上面的代码中，当准备要销毁Farm的对象时，将触发DESTROY方法，然后把农场对象的引用赋值给$self
(因为调用DESTROY的那一刻还能获取到农场对象的引用，所以调用DESTROY的时候还没有销毁农场对象)，然后for迭代所有的嵌套对象，直到DESTROY结束，Farm对象被真正销毁，Farm被销毁后，其内嵌套对象因为没有额外的引用数而随之被销毁。

然后创建一个程序文件small_farm.pl，在其中创建Farm对象，并加入两个Horse对象：
#!/usr/bin/env perl use strict; use warnings; use lib "lib"; use Horse; use
Farm; my $farm1 = Farm->new(); $farm1->add(Horse->new("baima"));
$farm1->add(Horse->new("heima")); print "burning the farm1...\n"; $farm1 =
undef; # 销毁$farm1对象 print "End of program\n";
输出结果：
burning the farm1... Farm=ARRAY(0x14dcf30) is being destroyed... baima goes
homeless heima goes homeless # DESTROY方法的代码块到此结束，下面将销毁Farm和嵌套的对象
Farm=ARRAY(0x14dcf30) destroyed... OBJECT-> heima <-died OBJECT-> baima <-died
End of program
当销毁farm1时，嵌套在其内部的horse也将被销毁。

如果，将$farm1拷贝一份:
my $farm2 = $farm1; print "burning the farm1...\n"; $farm1 = undef; #
销毁$farm1对象 print "End of program\n";
再执行：
burning the farm1... End of program Farm=ARRAY(0x1357f30) is being
destroyed... baima goes homeless heima goes homeless Farm=ARRAY(0x1357f30)
destroyed... OBJECT-> heima <-died OBJECT-> baima <-died
可见，销毁farm1时并没有销毁整个对象，直到程序结束时才进行销毁。

再者，将创建Horse对象的行为放在farm对象的外部：
my @horses = (Horse->new("baima"),Horse->new("heima")); my $farm1 =
Farm->new(); $farm1->add($horses[0]); $farm1->add($horses[1]); print "burning
the farm1...\n"; $farm1 = undef; # 销毁$farm1对象，但保留@horses print "farm1
gone...\n"; @horses = (); # 清空最后的引用@horses print "End of program\n";
上面每个horse对象都有两个引用，一个在农场farm1中，一个在数组@horses中。

输出结果：
burning the farm1... Farm=ARRAY(0x1835128) is being destroyed... baima goes
homeless heima goes homeless Farm=ARRAY(0x1835128) destroyed... farm1 gone...
OBJECT-> heima <-died OBJECT-> baima <-died End of program
显然，烧掉了farm1之后，减少了一次引用，直到@horses也被清空后才调用Animal中的DESTROY方法。

先销毁内层，再销毁外层


在前面的几次实验中，农场中嵌套的所有对象总时会随着Farm销毁而同时一次性被销毁，但是有时候我们可能会希望一个一个地销毁。换句话说，我们想要先销毁嵌套在Farm中的对象，最后再销毁Farm自身。也就是这两种循环的不同方式：
sub DESTROY { for($self->contents()){ print " ",$_->name, " goes homeless\n";
} } # 从此处开始，Farm和嵌套对象被一次性销毁 sub DESTROY { while(@$self) { my $who_homeless =
shift @$self; print " ",$who_homeless->name," goes homeless\n"; } }
上面的第二种方式之所以能够在DESTROY内部就销毁嵌套对象，是因为shift @$self的时候将嵌套的对象引用计数减少一，但却同时新建了一个
$who_homeless
词法变量引用这个对象，所以引用数仍然为1，但这个词法变量在一次循环之后就会被覆盖掉(最后一轮循环则是出了循环作用域被销毁)，从而使得嵌套的对象在每次进入下一轮循环的时候被销毁。

修改lib/Farm.pm：
#!/usr/bin/env perl use strict; use warnings; { package Farm; sub new { bless
[],shift } sub add { push @{shift()},shift } sub contents { @{shift()} } sub
DESTROY { my $self = shift; print "$self is being destroyed...\n";
while(@$self) { my $who_homeless = shift @$self; print "
",$who_homeless->name," goes homeless\n"; } } } 1;
修改small_farm.pl程序文件：
#!/usr/bin/env perl use strict; use warnings; use lib "lib"; use Horse; use
Farm; my $farm1 = Farm->new(); $farm1->add(Horse->new("baima"));
$farm1->add(Horse->new("heima")); print "burning the farm1...\n"; $farm1 =
undef; # 销毁$farm1对象，但保留@horses print "End of program\n";
执行结果：
burning the farm1... Farm=ARRAY(0x1a72f30) is being destroyed... baima goes
homeless OBJECT-> baima <-died heima goes homeless OBJECT-> heima <-died
Farm=ARRAY(0x1a72f30) destroyed... End of program
销毁对象善后示例


如果Farm、Animal创建对象时会打开一些文件句柄、生成一些临时文件，那么对象销毁可能需要手动去关闭文件句柄(不过perl一般会自动关闭)、清理对象的临时文件。

以模块File::Temp
的tempfile()函数生成临时文件为例，它会返回一个文件句柄和一个临时文件的名称。现在修改Animal类，使其构造对象时打开文件句柄并生成临时文件。

lib/Animal.pm文件中：
#!/usr/bin/env perl use strict; use warnings; use File::Temp qw(tempfile);
package Animal; sub new { my $class = shift; my $name = shift; my $self = {
Name => $name, Color => $class->default_color() }; my ($fh,$filename) =
File::Temp::tempfile(); $self->{temp_fh} = $fh; $self->{temp_filename} =
$filename; bless $self,$class; } sub DESTROY { # 善后 my $self = shift; my $fh =
$self->{temp_fh}; close $fh; unlink $self->{temp_filename}; print "OBJECT->
",$self->name()," <-died\n" } sub name { my $self = shift; ref $self ?
$self->{Name} : "an unamed Class $self"; } 1;
扩展继承的DESTROY


DESTROY和普通方法并没有什么区别，它可以被继承，也可以被重写。继承而来的DESTROY自然是共性的，如果子类需要额外的善后工作，就需要对父类的DESTROY进行扩展。


但重写DESTROY方法时，必须注意是扩展父类方法，而不是否定父类DESTROY的行为而完全重造一个新的DESTROY，因为子类并不知道父类的DESTROY有哪些善后操作。换句话说，重写DESTROY时，必须要调用父类的DESTROY，然后进行额外的扩展，否则本该父类善后的操作会被遗漏。

例如，为子类Horse添加一个DESTROY方法：
sub DESTROY { my $self = shift; $self->SUPER::DESTROY if $self->can(
"SUPER::DESTROY" ); print $self->name()," from subclass Horse gone\n"; }
在上面的代码中，还对SUPER::DESTROY进行了检测，因为子类不知道父类是否定义了DESTROY方法，但如果父类定义了，就应该去调用它。

再次声明，在子类重写DESTROY的时候，为了善后一切正常，必须在子类重写的DESTROY代码中包含$self->SUPER::DESTROY。

子类中额外的实例变量

要在子类中维护额外的实例变量，只需重写父类的构造方法即可。

例如Horse类下的RaceHorse子类，为其添加关于赛马战绩相关的4种额外实例数据：win、places、shows、losses。
package RaceHorse; use parent qw(Horse); sub new { my $self =
shift->SUPER::new(@_); $self->{$_} for qw(wins places shows losses); $self; }
关于重写父类构造方法，在前一篇文章中已经解释过。

只是这里需要注意的是，通过$self->{$_}的方式添加属性，其实已经"opened the
box"，破坏了面向对象的封装原则。但对于父类来说，如果能确保父类永远不会访问或涉及到这4种属性，那么是无关紧要的，这种情况对于Java来说，RaceHorse是父类Horse的友好成员，或者称之为"友好类"(friend
class)。如果父类中的属性可能会命名为这4种之一，那么名称冲突，这是不应该出现的，甚至父类的返回类型修改后不是hash而是数组，那就更严重了。


为了解耦这种依赖性问题，在创建子类的时候应当使用组合的方式而不是继承的方式。在此示例中，在创建RaceHorse类的时候，需要将Horse对象作为RaceHorse的一个实例数据，然后将剩余的数据放进独立的实例数据中，这样RaceHorse也将获得Horse对象的所有数据，还添加了属于自己的新数据，但因为不是继承关系，所以RaceHorse得把Horse类中的所有方法都重新写一遍，这可以通过"委托"的方式实现。虽然Perl支持委托，但委托的实现方式一般速度比较慢，也比较笨重。

不过对于本文来说，无所谓了，让它们以"友好类"的方式存在即可。

添加几个访问这些属性的方法：
sub won { shift->{wins}++; } sub placed { shift->{places}++; } sub showed {
shift->{shows}++; } sub lost { shift->{losses}++; } sub standings { my $self =
shift; join ', ', map "$self->{$_} $_", qw(wins places shows losses); }
每调用一次won()表示赢一次，standings()表示输出战绩。

类变量(管理注册信息)


可以使用类变量跟踪所有已创建的对象。比如使用一个hash结构的变量，将各个对象的引用保存到hash的值。那么什么作为hash的key？可以将对象的hash结构字符串化后(stringfy)的字符串作为key。

hash结构字符串化是什么意思？看下面：
my %myhash = ( name => "longshuai", age => 23, ); print %myhash,"\n";

print输出的"namelongshuaiage23"就是hash结构字符串化的结果。字符串化的结果是将所有key和value都连在一起形成一个字符串。注意，hash结构的字符串化不能插入到双引号中，所以
print "%myhash"是不会字符串化的，而是直接输出%myhash。

所以，如果一个hash变量%HASH1，其中一个value为%myhash结构，那么这个%HASH1的结构大致如下：
%HASH1 { ... namelongshuaiage23 => { name => "longshuai",age => 23 }, ... }

所以，将对象的hash数据结构作为value，对象字符串化的字符串作为key，可以保证所有的对象都是唯一的，除非创建的对象是完全一致的。这个key其实没有用处，只是用来充当占位符，使得对象的数据结构能嵌套保存到hash结构中。当然，采取什么作为key并没有要求，只要能保证对象的唯一性就可以。

现在可以扩展一下Animal的构造方法：
my %REGISTRY; sub new { my $class = shift; my $name = shift; my $self = { Name
=> $name, Color => $class->default_color() }; bless $self,$class;
$REGISTRY{$self} = $self; }
此处以一个词法的hash变量记录注册对象创建信息，每调用new创建一次对象，就将对象引用(hash结构)保存到hash结构%REGISTER
中，由于最后一句是赋值语句，所以返回值也是$self，也就是说返回的是这个新创建的对象。

创建的对象注册到%REGISTRY中后，还需要方法去取得这个对象，例如：
sub registered { return map { "a ".ref($_)." named ".$_->name } values
%REGISTRY; }
虽然类变量跟踪了已经创建的变量，但正因为%REGISTRY中多了一份对象的引用，使得对象的销毁时间点将出乎预料。例如，下面的代码：
{ my $horse1 = Horse->new("baima"); $horse1->speak(); }
正常情况下，horse1对象将从代码块结束的那个位置开始销毁，但此时Animal的类变量中还记录了该对象的引用，引用数没有减为0，所以$horse1
不会被销毁。

如果想要避免这种情况，可以创建一个不会被跟踪的对象，然后通过它的DESTROY方法去delete保存在Animal类变量%REGISTRY
中的元素。显然，这是很不合理行为。另一种方式是使用弱引用，见下文。

弱引用

弱引用(weaken reference)是从perl v5.8版本之后引入的功能，它位于Scalar::Util模块中。一个引用转换
为弱引用后，它不会被引用计数，当普通的引用计数减为0后，该数据结构将被销毁，然后这个弱引用将被设置为undef。

下面一个示例即可解释清楚。修改下Animal的构造方法new()：
use Scalar::Util qw(weaken); sub new { ref(my $class = shift) and croak 'class
only'; my $name = shift; my $self = { Name => $name, Color =>
$class->default_color }; bless $self, $class; $REGISTRY{$self} = $self;
weaken($REGISTRY{$self}); $self; }
上面$REGISTRY{$self} = $self;会增加一次引用计数，但随后的weaken($REGISTRY{$self});
会将此引用转换为弱引用，使得hash的key部分不再强引用这个对象，所以会减少一次引用计数，使得最终new()退出时将只剩下一次引用计数。

弱引用还能解决内存泄漏问题，这是采用引用计数管理内存的通病，因为它们无法解决引用环路。例如$a引用$b，$b又引用$a
，a想要释放就得释放b，b想要释放就得释放a，导致它两的引用计数始终无法减为0，占用的内存永远不会释放。通过弱引用的方式，随便将a或是b转换为弱引用都能解决引用环路问题，问题是转换a好还是转换b好呢？


对于对象之间的引用环路来说，转换父类比转换子类好，因为父类只要不需要了就可以直接销毁，此时子类也会随之销毁。而转换子类时，子类在不需要的时候被销毁，但父类可能还在引用别的，也就是说父类不一定会被销毁。

另外，在使用弱引用的时候要非常小心，能不用的时候尽量别用，否则一出问题，非常难调试排查。

• « 上一篇：云计算、大数据和人工智能，谁将开启新时代？
• » 下一篇：就业｜大数据人才的岗位薪资水平到底有多高？